@hubspot/cli 7.7.27-experimental.2 → 7.7.28-experimental.0

package/lib/__tests__/importData.test.js

@@ -0,0 +1,89 @@
+import { uiLogger } from '../ui/logger.js';
+import { createImport } from '@hubspot/local-dev-lib/api/crm';
+import { getAccountConfig, getAccountId } from '@hubspot/local-dev-lib/config';
+import { handleImportData, handleTargetTestAccountSelectionFlow, } from '../importData.js';
+import { lib } from '../../lang/en.js';
+import { isDeveloperTestAccount, isStandardAccount, isAppDeveloperAccount, } from '../accountTypes.js';
+import { importDataTestAccountSelectPrompt } from '../prompts/importDataTestAccountSelectPrompt.js';
+vi.mock('../ui/logger');
+vi.mock('@hubspot/local-dev-lib/api/crm');
+vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('../accountTypes');
+vi.mock('../prompts/importDataTestAccountSelectPrompt');
+describe('lib/importData', () => {
+    const mockUiLogger = vi.mocked(uiLogger);
+    const mockCreateImport = vi.mocked(createImport);
+    const mockGetAccountConfig = vi.mocked(getAccountConfig);
+    const mockGetAccountId = vi.mocked(getAccountId);
+    const mockIsDeveloperTestAccount = vi.mocked(isDeveloperTestAccount);
+    const mockIsStandardAccount = vi.mocked(isStandardAccount);
+    const mockIsAppDeveloperAccount = vi.mocked(isAppDeveloperAccount);
+    const mockImportDataTestAccountSelectPrompt = vi.mocked(importDataTestAccountSelectPrompt);
+    beforeEach(() => {
+        mockUiLogger.info.mockReset();
+        mockUiLogger.success.mockReset();
+        mockUiLogger.error.mockReset();
+        mockCreateImport.mockReset();
+        mockGetAccountConfig.mockReset();
+        mockGetAccountId.mockReset();
+        mockIsDeveloperTestAccount.mockReset();
+        mockIsStandardAccount.mockReset();
+        mockIsAppDeveloperAccount.mockReset();
+        mockImportDataTestAccountSelectPrompt.mockReset();
+    });
+    describe('handleImportData', () => {
+        const targetAccountId = 123456789;
+        const dataFileNames = ['test-file.json'];
+        const importRequest = {
+            name: 'test-import',
+        };
+        it('should log the correct success message', async () => {
+            // @ts-expect-error - mockCreateImport is not typed correctly
+            mockCreateImport.mockResolvedValue({
+                data: { id: '123' },
+            });
+            await handleImportData(targetAccountId, dataFileNames, importRequest);
+            expect(mockUiLogger.success).toHaveBeenCalledWith(lib.importData.viewImportLink('https://app.hubspot.com', targetAccountId, '123'));
+        });
+        it('should log the correct error message', async () => {
+            mockCreateImport.mockRejectedValue(new Error('test-error'));
+            // weird because we catch the error, log a specific message, and then throw it again
+            await expect(handleImportData(targetAccountId, dataFileNames, importRequest)).rejects.toThrow('test-error');
+            expect(mockUiLogger.error).toHaveBeenCalledWith(lib.importData.errors.failedToImportData);
+        });
+    });
+    describe('handleTargetTestAccountSelectionFlow', () => {
+        const userProvidedAccountId = '1234';
+        const derivedAccountId = 123456789;
+        it('should error if the userProvidedAccountId is not the right account type', async () => {
+            mockGetAccountConfig.mockReturnValue({});
+            mockGetAccountId.mockReturnValue(1234);
+            mockIsDeveloperTestAccount.mockReturnValue(false);
+            await expect(handleTargetTestAccountSelectionFlow(derivedAccountId, userProvidedAccountId)).rejects.toThrow(lib.importData.errors.notDeveloperTestAccount);
+        });
+        it('should error if the derivedAccountId belongs to the wrong account type', async () => {
+            mockGetAccountConfig.mockReturnValue({});
+            mockIsDeveloperTestAccount.mockReturnValue(false);
+            mockIsStandardAccount.mockReturnValue(false);
+            mockIsAppDeveloperAccount.mockReturnValue(false);
+            await expect(handleTargetTestAccountSelectionFlow(derivedAccountId, undefined)).rejects.toThrow(lib.importData.errors.incorrectAccountType(derivedAccountId));
+        });
+        it('should return the derivedAccountId if it is a developer test account', async () => {
+            mockGetAccountConfig.mockReturnValue({});
+            mockIsDeveloperTestAccount.mockReturnValue(true);
+            const result = await handleTargetTestAccountSelectionFlow(derivedAccountId, undefined);
+            expect(result).toBe(derivedAccountId);
+        });
+        it('should return the result of the importDataTestAccountSelectPrompt if the derivedAccountId is a standard or app developer account', async () => {
+            mockGetAccountConfig.mockReturnValue({});
+            mockIsDeveloperTestAccount.mockReturnValue(false);
+            mockIsStandardAccount.mockReturnValue(true);
+            mockIsAppDeveloperAccount.mockReturnValue(true);
+            mockImportDataTestAccountSelectPrompt.mockResolvedValue({
+                selectedAccountId: 890223,
+            });
+            const result = await handleTargetTestAccountSelectionFlow(derivedAccountId, undefined);
+            expect(result).toBe(890223);
+        });
+    });
+});

package/lib/accountTypes.js

@@ -1,6 +1,5 @@
 import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
-import { hasFeature } from './hasFeature.js';
-import { FEATURES } from './constants.js';
+import { hasUnfiedAppsAccess } from './hasFeature.js';
 import { getAccountIdentifier } from '@hubspot/local-dev-lib/config/getAccountIdentifier';
 function isAccountType(accountConfig, accountType) {
     return Boolean(accountConfig.accountType && accountType.includes(accountConfig.accountType));
@@ -40,5 +39,5 @@ export async function isUnifiedAccount(account) {
     if (!accountId) {
         return false;
     }
-    return hasFeature(accountId, FEATURES.UNIFIED_APPS);
+    return hasUnfiedAppsAccess(accountId);
 }

package/lib/app/__tests__/migrate.test.js

@@ -1,7 +1,7 @@
 import { logger } from '@hubspot/local-dev-lib/logger';
 import { getCwd, sanitizeFileName } from '@hubspot/local-dev-lib/path';
 import { extractZipArchive } from '@hubspot/local-dev-lib/archive';
-import { validateUid } from '@hubspot/project-parsing-lib';
+import { validateUid, getProjectThemeDetails, } from '@hubspot/project-parsing-lib';
 import { UNMIGRATABLE_REASONS } from '@hubspot/local-dev-lib/constants/projects';
 import { MIGRATION_STATUS } from '@hubspot/local-dev-lib/types/Migration';
 import { downloadProject } from '@hubspot/local-dev-lib/api/projects';
@@ -9,10 +9,10 @@ import fs from 'fs';
 import { confirmPrompt, inputPrompt, listPrompt, } from '../../prompts/promptUtils.js';
 import { ensureProjectExists } from '../../projects/ensureProjectExists.js';
 import { poll } from '../../polling.js';
-import { CLI_UNMIGRATABLE_REASONS, continueMigration, initializeMigration, listAppsForMigration, } from '../../../api/migrate.js';
+import { CLI_UNMIGRATABLE_REASONS, continueAppMigration, initializeAppMigration, listAppsForMigration, } from '../../../api/migrate.js';
 import { lib } from '../../../lang/en.js';
-import { hasFeature } from '../../hasFeature.js';
-import { getUnmigratableReason, generateFilterAppsByProjectNameFunction, buildErrorMessageFromMigrationStatus, fetchMigrationApps, promptForAppToMigrate, selectAppToMigrate, handleMigrationSetup, beginMigration, pollMigrationStatus, finalizeMigration, downloadProjectFiles, migrateApp2025_2, logInvalidAccountError, } from '../migrate.js';
+import { hasUnfiedAppsAccess } from '../../hasFeature.js';
+import { getUnmigratableReason, generateFilterAppsByProjectNameFunction, buildErrorMessageFromMigrationStatus, fetchMigrationApps, promptForAppToMigrate, selectAppToMigrate, handleMigrationSetup, getHasMigratableThemes, beginAppMigration, pollMigrationStatus, finalizeAppMigration, downloadProjectFiles, migrateApp2025_2, logInvalidAccountError, validateMigrationAppsAndThemes, } from '../migrate.js';
 vi.mock('@hubspot/local-dev-lib/logger');
 vi.mock('@hubspot/local-dev-lib/path');
 vi.mock('@hubspot/local-dev-lib/archive');
@@ -40,9 +40,10 @@ const mockedListPrompt = listPrompt;
 const mockedEnsureProjectExists = ensureProjectExists;
 const mockedPoll = poll;
 const mockedListAppsForMigration = listAppsForMigration;
-const mockedInitializeMigration = initializeMigration;
-const mockedContinueMigration = continueMigration;
-const mockedHasFeature = hasFeature;
+const mockedGetProjectThemeDetails = getProjectThemeDetails;
+const mockedInitializeAppMigration = initializeAppMigration;
+const mockedContinueAppMigration = continueAppMigration;
+const mockedHasUnfiedAppsAccess = hasUnfiedAppsAccess;
 const mockedFs = fs;
 const createMockMigratableApp = (id, name, projectName) => ({
     appId: id,
@@ -60,7 +61,7 @@ const createMockUnmigratableApp = (id, name, reason) => ({
     migrationComponents: [],
 });
 const createLoadedProjectConfig = (name) => ({
-    projectConfig: { name },
+    projectConfig: { name, srcDir: 'src' },
     projectDir: MOCK_PROJECT_DIR,
 });
 const ACCOUNT_ID = 123;
@@ -81,7 +82,7 @@ describe('lib/app/migrate', () => {
         mockedGetCwd.mockReturnValue(MOCK_CWD);
         mockedSanitizeFileName.mockImplementation(name => name);
         mockedValidateUid.mockReturnValue(undefined);
-        mockedHasFeature.mockResolvedValue(true);
+        mockedHasUnfiedAppsAccess.mockResolvedValue(true);
         mockedFs.renameSync.mockImplementation(() => { });
     });
     describe('getUnmigratableReason', () => {
@@ -191,36 +192,71 @@ describe('lib/app/migrate', () => {
         });
         it('should return all apps when no projectConfig is provided', async () => {
             setupMockApps([createMockMigratableApp(1, 'App 1')]);
-            const result = await fetchMigrationApps(undefined, ACCOUNT_ID, PLATFORM_VERSION);
-            expect(result).toHaveLength(1);
-            expect(result[0].appId).toBe(1);
+            const result = await fetchMigrationApps(ACCOUNT_ID, PLATFORM_VERSION);
+            expect(result.migratableApps).toHaveLength(1);
+            expect(result.migratableApps[0].appId).toBe(1);
+            expect(result.unmigratableApps).toHaveLength(0);
         });
         it('should filter apps by project name when projectConfig is provided', async () => {
             const projectConfig = createLoadedProjectConfig(PROJECT_NAME);
             setupMockApps([createMockMigratableApp(1, 'App 1', PROJECT_NAME)]);
-            const result = await fetchMigrationApps(undefined, ACCOUNT_ID, PLATFORM_VERSION, projectConfig);
-            expect(result).toHaveLength(1);
-            expect(result[0].projectName).toBe(PROJECT_NAME);
+            const result = await fetchMigrationApps(ACCOUNT_ID, PLATFORM_VERSION, projectConfig);
+            expect(result.migratableApps).toHaveLength(1);
+            expect(result.migratableApps[0].projectName).toBe(PROJECT_NAME);
         });
+    });
+    describe('getHasMigratableThemes', () => {
+        it('should return false when no projectConfig is provided', async () => {
+            const result = await getHasMigratableThemes();
+            expect(result).toEqual({
+                hasMigratableThemes: false,
+                migratableThemesCount: 0,
+            });
+        });
+        it('should return true when there are migratable themes', async () => {
+            mockedGetProjectThemeDetails.mockResolvedValue({
+                legacyThemeDetails: [
+                    {
+                        configFilepath: 'src/theme.json',
+                        themePath: 'src/theme',
+                        themeConfig: {
+                            secret_names: ['my-secret'],
+                        },
+                    },
+                ],
+                legacyReactThemeDetails: [],
+            });
+            const projectConfig = createLoadedProjectConfig(PROJECT_NAME);
+            const result = await getHasMigratableThemes(projectConfig);
+            expect(result).toEqual({
+                hasMigratableThemes: true,
+                migratableThemesCount: 1,
+            });
+        });
+    });
+    describe('validateMigrationAppsAndThemes', () => {
+        const mockMigratableApp1 = createMockMigratableApp(1, 'App 1', PROJECT_NAME);
+        const mockMigratableApp2 = createMockMigratableApp(2, 'App 2', PROJECT_NAME);
         it('should throw an error when multiple apps are found for a project', async () => {
             const projectConfig = createLoadedProjectConfig(PROJECT_NAME);
-            setupMockApps([
-                createMockMigratableApp(1, 'App 1', PROJECT_NAME),
-                createMockMigratableApp(2, 'App 2', PROJECT_NAME),
-            ]);
-            await expect(fetchMigrationApps(undefined, ACCOUNT_ID, PLATFORM_VERSION, projectConfig)).rejects.toThrow(lib.migrate.errors.project.multipleApps);
+            await expect(validateMigrationAppsAndThemes(APP_ID, ACCOUNT_ID, {
+                migratableApps: [mockMigratableApp1, mockMigratableApp2],
+                unmigratableApps: [],
+            }, false, projectConfig)).rejects.toThrow(lib.migrate.errors.project.multipleApps);
+        });
+        it('should throw an error when cms themes are found for a project', async () => {
+            const projectConfig = createLoadedProjectConfig(PROJECT_NAME);
+            await expect(validateMigrationAppsAndThemes(APP_ID, ACCOUNT_ID, { migratableApps: [mockMigratableApp1], unmigratableApps: [] }, true, projectConfig)).rejects.toThrow(lib.migrate.errors.project.themesAndAppsNotAllowed);
         });
         it('should throw an error when no apps are found for a project', async () => {
             const projectConfig = createLoadedProjectConfig(PROJECT_NAME);
-            setupMockApps([], []);
-            await expect(fetchMigrationApps(undefined, ACCOUNT_ID, PLATFORM_VERSION, projectConfig)).rejects.toThrow(lib.migrate.errors.noAppsForProject(PROJECT_NAME));
+            await expect(validateMigrationAppsAndThemes(APP_ID, ACCOUNT_ID, { migratableApps: [], unmigratableApps: [] }, false, projectConfig)).rejects.toThrow(lib.migrate.errors.noAppsForProject(PROJECT_NAME));
         });
         it('should throw an error when no migratable apps are found', async () => {
-            setupMockApps([], mockUnmigratableApps);
-            await expect(fetchMigrationApps(undefined, ACCOUNT_ID, PLATFORM_VERSION)).rejects.toThrow(/No apps in account/);
+            await expect(validateMigrationAppsAndThemes(APP_ID, ACCOUNT_ID, { migratableApps: [], unmigratableApps: mockUnmigratableApps }, false)).rejects.toThrow(/No apps in account/);
         });
         it('should throw an error when appId is provided but not found', async () => {
-            await expect(fetchMigrationApps(999, ACCOUNT_ID, PLATFORM_VERSION)).rejects.toThrow(/No apps in account/);
+            await expect(validateMigrationAppsAndThemes(APP_ID, ACCOUNT_ID, { migratableApps: [], unmigratableApps: [] }, false)).rejects.toThrow(/No apps in account/);
         });
     });
     describe('promptForAppToMigrate', () => {
@@ -294,6 +330,10 @@ describe('lib/app/migrate', () => {
                     unmigratableApps: [],
                 },
             });
+            mockedGetProjectThemeDetails.mockResolvedValue({
+                legacyThemeDetails: [],
+                legacyReactThemeDetails: [],
+            });
             mockedListPrompt.mockResolvedValue({ appId: 1 });
             mockedConfirmPrompt.mockResolvedValue(true);
             mockedEnsureProjectExists.mockResolvedValue({ projectExists: false });
@@ -312,11 +352,16 @@ describe('lib/app/migrate', () => {
                     unmigratableApps: [],
                 },
             });
+            mockedGetProjectThemeDetails.mockResolvedValueOnce({
+                legacyThemeDetails: [],
+                legacyReactThemeDetails: [],
+            });
             const result = await handleMigrationSetup(ACCOUNT_ID, defaultOptions, projectConfig);
             expect(result).toEqual({
                 appIdToMigrate: 1,
                 projectName: PROJECT_NAME,
                 projectDest: MOCK_PROJECT_DIR,
+                isThemesMigration: false,
             });
         });
         it('should prompt for project name when not provided', async () => {
@@ -336,10 +381,10 @@ describe('lib/app/migrate', () => {
             await expect(handleMigrationSetup(ACCOUNT_ID, defaultOptions)).rejects.toThrow(lib.migrate.errors.project.alreadyExists(PROJECT_NAME));
         });
     });
-    describe('beginMigration', () => {
+    describe('beginAppMigration', () => {
         beforeEach(() => {
             // @ts-expect-error
-            mockedInitializeMigration.mockResolvedValue({
+            mockedInitializeAppMigration.mockResolvedValue({
                 data: { migrationId: MIGRATION_ID },
             });
             mockedPoll.mockResolvedValue({
@@ -350,7 +395,7 @@ describe('lib/app/migrate', () => {
             mockedInputPrompt.mockResolvedValue('test-uid');
         });
         it('should initialize migration and return migrationId and uidMap', async () => {
-            const result = await beginMigration(ACCOUNT_ID, APP_ID, PLATFORM_VERSION);
+            const result = await beginAppMigration(ACCOUNT_ID, APP_ID, PLATFORM_VERSION);
             expect(result).toEqual({
                 migrationId: MIGRATION_ID,
                 uidMap: {},
@@ -368,7 +413,7 @@ describe('lib/app/migrate', () => {
                     },
                 },
             });
-            await beginMigration(ACCOUNT_ID, APP_ID, PLATFORM_VERSION);
+            await beginAppMigration(ACCOUNT_ID, APP_ID, PLATFORM_VERSION);
             expect(mockedInputPrompt).toHaveBeenCalledWith(lib.migrate.prompt.uidForComponent("card 'test-card' (ID: 1)"), {
                 defaultAnswer: componentHint,
                 validate: expect.any(Function),
@@ -376,7 +421,7 @@ describe('lib/app/migrate', () => {
         });
         it('should throw an error when migration fails', async () => {
             mockedPoll.mockRejectedValue(new Error('Failed'));
-            await expect(beginMigration(ACCOUNT_ID, APP_ID, PLATFORM_VERSION)).rejects.toThrow(/Migration Failed/);
+            await expect(beginAppMigration(ACCOUNT_ID, APP_ID, PLATFORM_VERSION)).rejects.toThrow(/Migration Failed/);
         });
     });
     describe('pollMigrationStatus', () => {
@@ -392,11 +437,11 @@ describe('lib/app/migrate', () => {
             expect(result).toBe(mockStatus);
         });
     });
-    describe('finalizeMigration', () => {
+    describe('finalizeAppMigration', () => {
         const uidMap = { '1': 'test-uid' };
         beforeEach(() => {
             // @ts-expect-error
-            mockedContinueMigration.mockResolvedValue({
+            mockedContinueAppMigration.mockResolvedValue({
                 data: { migrationId: MIGRATION_ID },
             });
             mockedPoll.mockResolvedValue({
@@ -406,12 +451,12 @@ describe('lib/app/migrate', () => {
             });
         });
         it('should continue migration and return buildId', async () => {
-            const result = await finalizeMigration(ACCOUNT_ID, MIGRATION_ID, uidMap, PROJECT_NAME);
+            const result = await finalizeAppMigration(ACCOUNT_ID, MIGRATION_ID, uidMap, PROJECT_NAME);
             expect(result).toBe(BUILD_ID);
         });
         it('should throw an error when migration fails', async () => {
             mockedPoll.mockRejectedValue(new Error('Test error'));
-            await expect(finalizeMigration(ACCOUNT_ID, MIGRATION_ID, uidMap, PROJECT_NAME)).rejects.toThrow(/Migration Failed/);
+            await expect(finalizeAppMigration(ACCOUNT_ID, MIGRATION_ID, uidMap, PROJECT_NAME)).rejects.toThrow(/Migration Failed/);
         });
     });
     describe('downloadProjectFiles', () => {
@@ -459,10 +504,10 @@ describe('lib/app/migrate', () => {
             unstable: false,
         };
         beforeEach(() => {
-            mockedHasFeature.mockResolvedValue(true);
+            mockedHasUnfiedAppsAccess.mockResolvedValue(true);
         });
         it('should throw an error when account is not ungated for unified apps', async () => {
-            mockedHasFeature.mockResolvedValueOnce(false);
+            mockedHasUnfiedAppsAccess.mockResolvedValueOnce(false);
             await expect(migrateApp2025_2(ACCOUNT_ID, options)).rejects.toThrowError(/isn't enrolled in the required product beta to access this command./);
         });
         it('should throw an error when projectConfig is invalid', async () => {

package/lib/app/migrate.d.ts

@@ -1,6 +1,6 @@
 import { ArgumentsCamelCase } from 'yargs';
 import { LoadedProjectConfig } from '../projects/config.js';
-import { MigrationApp, MigrationFailed, MigrationStatus } from '../../api/migrate.js';
+import { MigrationApp, MigratableApp, UnmigratableApp, MigrationFailed, MigrationStatus } from '../../api/migrate.js';
 import { AccountArgs, CommonArgs, ConfigArgs, EnvironmentArgs } from '../../types/Yargs.js';
 export type MigrateAppArgs = CommonArgs & AccountArgs & EnvironmentArgs & ConfigArgs & {
     name?: string;
@@ -12,7 +12,18 @@ export type MigrateAppArgs = CommonArgs & AccountArgs & EnvironmentArgs & Config
 export declare function getUnmigratableReason(reasonCode: string, projectName: string | undefined, accountId: number): string;
 export declare function generateFilterAppsByProjectNameFunction(projectConfig?: LoadedProjectConfig): (app: MigrationApp) => boolean;
 export declare function buildErrorMessageFromMigrationStatus(error: MigrationFailed): string;
-export declare function fetchMigrationApps(appId: MigrateAppArgs['appId'], derivedAccountId: number, platformVersion: string, projectConfig?: LoadedProjectConfig): Promise<MigrationApp[]>;
+export declare function getHasMigratableThemes(projectConfig?: LoadedProjectConfig): Promise<{
+    hasMigratableThemes: boolean;
+    migratableThemesCount: number;
+}>;
+export declare function fetchMigrationApps(derivedAccountId: number, platformVersion: string, projectConfig?: LoadedProjectConfig): Promise<{
+    migratableApps: MigratableApp[];
+    unmigratableApps: UnmigratableApp[];
+}>;
+export declare function validateMigrationAppsAndThemes(appId: MigrateAppArgs['appId'], derivedAccountId: number, { migratableApps, unmigratableApps, }: {
+    migratableApps: MigratableApp[];
+    unmigratableApps: UnmigratableApp[];
+}, hasMigratableThemes: boolean, projectConfig?: LoadedProjectConfig): Promise<void>;
 export declare function promptForAppToMigrate(allApps: MigrationApp[], derivedAccountId: number): Promise<number>;
 export declare function selectAppToMigrate(allApps: MigrationApp[], derivedAccountId: number, appId?: number): Promise<{
     proceed: boolean;
@@ -22,13 +33,15 @@ export declare function handleMigrationSetup(derivedAccountId: number, options:
     appIdToMigrate?: number | undefined;
     projectName?: string;
     projectDest?: string;
+    isThemesMigration?: boolean;
 }>;
-export declare function beginMigration(derivedAccountId: number, appId: number, platformVersion: string): Promise<{
+export declare function handleThemesMigration(projectConfig: LoadedProjectConfig, platformVersion: string): Promise<void>;
+export declare function beginAppMigration(derivedAccountId: number, appId: number, platformVersion: string): Promise<{
     migrationId: number;
     uidMap: Record<string, string>;
 } | undefined>;
 export declare function pollMigrationStatus(derivedAccountId: number, migrationId: number, successStates?: string[]): Promise<MigrationStatus>;
-export declare function finalizeMigration(derivedAccountId: number, migrationId: number, uidMap: Record<string, string>, projectName: string): Promise<number>;
+export declare function finalizeAppMigration(derivedAccountId: number, migrationId: number, uidMap: Record<string, string>, projectName: string): Promise<number>;
 export declare function downloadProjectFiles(derivedAccountId: number, projectName: string, buildId: number, projectDest: string, projectConfig?: LoadedProjectConfig): Promise<void>;
 export declare function migrateApp2025_2(derivedAccountId: number, options: ArgumentsCamelCase<MigrateAppArgs>, projectConfig?: LoadedProjectConfig): Promise<void>;
 export declare function logInvalidAccountError(): void;

package/lib/app/migrate.js

@@ -2,7 +2,7 @@ import path from 'path';
 import { getCwd, sanitizeFileName } from '@hubspot/local-dev-lib/path';
 import { extractZipArchive } from '@hubspot/local-dev-lib/archive';
 import chalk from 'chalk';
-import { validateUid } from '@hubspot/project-parsing-lib';
+import { validateUid, migrateThemes, getProjectThemeDetails, } from '@hubspot/project-parsing-lib';
 import { UNMIGRATABLE_REASONS } from '@hubspot/local-dev-lib/constants/projects';
 import { mapToUserFacingType } from '@hubspot/project-parsing-lib/src/lib/transform.js';
 import { MIGRATION_STATUS } from '@hubspot/local-dev-lib/types/Migration';
@@ -10,16 +10,19 @@ import { downloadProject } from '@hubspot/local-dev-lib/api/projects';
 import { Separator } from '@inquirer/prompts';
 import { confirmPrompt, inputPrompt, listPrompt, } from '../prompts/promptUtils.js';
 import { uiAccountDescription, uiCommandReference, uiLine, uiLink, } from '../ui/index.js';
+import { writeProjectConfig } from '../projects/config.js';
 import { ensureProjectExists } from '../projects/ensureProjectExists.js';
 import SpinniesManager from '../ui/SpinniesManager.js';
 import { DEFAULT_POLLING_STATUS_LOOKUP, poll } from '../polling.js';
-import { checkMigrationStatusV2, CLI_UNMIGRATABLE_REASONS, continueMigration, initializeMigration, isMigrationStatus, listAppsForMigration, } from '../../api/migrate.js';
+import { checkMigrationStatusV2, CLI_UNMIGRATABLE_REASONS, continueAppMigration, initializeAppMigration, isMigrationStatus, listAppsForMigration, } from '../../api/migrate.js';
 import fs from 'fs';
 import { lib } from '../../lang/en.js';
-import { hasFeature } from '../hasFeature.js';
-import { FEATURES } from '../constants.js';
+import { PROJECT_CONFIG_FILE } from '../constants.js';
+import { hasUnfiedAppsAccess } from '../hasFeature.js';
 import { getProjectBuildDetailUrl, getProjectDetailUrl, } from '../projects/urls.js';
 import { uiLogger } from '../ui/logger.js';
+import { debugError } from '../errorHandlers/index.js';
+import { useV3Api } from '../projects/buildAndDeploy.js';
 export function getUnmigratableReason(reasonCode, projectName, accountId) {
     switch (reasonCode) {
         case UNMIGRATABLE_REASONS.UP_TO_DATE:
@@ -56,14 +59,43 @@ export function buildErrorMessageFromMigrationStatus(error) {
     })
         .join('\n\t- ')}`;
 }
-export async function fetchMigrationApps(appId, derivedAccountId, platformVersion, projectConfig) {
+export async function getHasMigratableThemes(projectConfig) {
+    if (!projectConfig?.projectConfig?.name || !projectConfig?.projectDir) {
+        return { hasMigratableThemes: false, migratableThemesCount: 0 };
+    }
+    const projectSrcDir = path.resolve(projectConfig.projectDir, projectConfig.projectConfig.srcDir);
+    const { legacyThemeDetails, legacyReactThemeDetails } = await getProjectThemeDetails(projectSrcDir);
+    return {
+        hasMigratableThemes: legacyThemeDetails.length > 0 || legacyReactThemeDetails.length > 0,
+        migratableThemesCount: legacyThemeDetails.length + legacyReactThemeDetails.length,
+    };
+}
+export async function fetchMigrationApps(derivedAccountId, platformVersion, projectConfig) {
     const { data: { migratableApps, unmigratableApps }, } = await listAppsForMigration(derivedAccountId, platformVersion);
     const filteredMigratableApps = migratableApps.filter(generateFilterAppsByProjectNameFunction(projectConfig));
     const filteredUnmigratableApps = unmigratableApps.filter(generateFilterAppsByProjectNameFunction(projectConfig));
-    const allApps = [...filteredMigratableApps, ...filteredUnmigratableApps];
+    return {
+        migratableApps: filteredMigratableApps,
+        unmigratableApps: filteredUnmigratableApps,
+    };
+}
+export async function validateMigrationAppsAndThemes(appId, derivedAccountId, { migratableApps, unmigratableApps, }, hasMigratableThemes, projectConfig) {
+    const allApps = [...migratableApps, ...unmigratableApps];
     if (allApps.length > 1 && projectConfig) {
         throw new Error(lib.migrate.errors.project.multipleApps);
     }
+    if (hasMigratableThemes) {
+        if (useV3Api(projectConfig?.projectConfig?.platformVersion)) {
+            throw new Error(lib.migrate.errors.project.themesAlreadyMigrated);
+        }
+        if (allApps.length > 0 && projectConfig) {
+            throw new Error(lib.migrate.errors.project.themesAndAppsNotAllowed);
+        }
+        if (!projectConfig) {
+            throw new Error(lib.migrate.errors.project.noProjectForThemesMigration);
+        }
+        return;
+    }
     if (!projectConfig?.projectConfig) {
         allApps.forEach(app => {
             if (app.projectName) {
@@ -77,7 +109,7 @@ export async function fetchMigrationApps(appId, derivedAccountId, platformVersio
         throw new Error(lib.migrate.errors.noAppsForProject(projectConfig?.projectConfig?.name || ''));
     }
     if (allApps.length === 0 || !allApps.some(app => app.isMigratable)) {
-        const reasons = filteredUnmigratableApps.map(app => `${chalk.bold(app.appName)}: ${getUnmigratableReason(app.unmigratableReason, app.projectName, derivedAccountId)}`);
+        const reasons = unmigratableApps.map(app => `${chalk.bold(app.appName)}: ${getUnmigratableReason(app.unmigratableReason, app.projectName, derivedAccountId)}`);
         throw new Error(lib.migrate.errors.noAppsEligible(uiAccountDescription(derivedAccountId), reasons));
     }
     if (appId &&
@@ -86,7 +118,6 @@ export async function fetchMigrationApps(appId, derivedAccountId, platformVersio
         })) {
         throw new Error(lib.migrate.errors.appWithAppIdNotFound(appId));
     }
-    return allApps;
 }
 export async function promptForAppToMigrate(allApps, derivedAccountId) {
     const appChoices = allApps.map(app => ({
@@ -143,18 +174,39 @@ export async function selectAppToMigrate(allApps, derivedAccountId, appId) {
     };
 }
 export async function handleMigrationSetup(derivedAccountId, options, projectConfig) {
+    SpinniesManager.add('checkingForMigratableComponents', {
+        text: lib.migrate.spinners.checkingForMigratableComponents,
+    });
     const { name, dest, appId } = options;
-    const allApps = await fetchMigrationApps(appId, derivedAccountId, options.platformVersion, projectConfig);
-    const { proceed, appIdToMigrate } = await selectAppToMigrate(allApps, derivedAccountId, appId);
+    const { hasMigratableThemes, migratableThemesCount } = await getHasMigratableThemes(projectConfig);
+    const { migratableApps, unmigratableApps } = await fetchMigrationApps(derivedAccountId, options.platformVersion, projectConfig);
+    SpinniesManager.remove('checkingForMigratableComponents');
+    await validateMigrationAppsAndThemes(appId, derivedAccountId, { migratableApps, unmigratableApps }, hasMigratableThemes, projectConfig);
+    const allApps = [...migratableApps, ...unmigratableApps];
+    let proceed = false;
+    let appIdToMigrate;
+    if (hasMigratableThemes) {
+        uiLogger.log(lib.migrate.prompt.themesMigration(migratableThemesCount));
+        proceed = await confirmPrompt(lib.migrate.prompt.proceed, {
+            defaultAnswer: false,
+        });
+    }
+    else {
+        const appSelectionPrompt = await selectAppToMigrate(allApps, derivedAccountId, appId);
+        appIdToMigrate = appSelectionPrompt.appIdToMigrate;
+        proceed = appSelectionPrompt.proceed;
+    }
     if (!proceed) {
         return {};
     }
     // If it's a project we don't want to prompt for dest and name, so just return early
+    // Theme migrations can only be initiated from the project directory
     if (projectConfig &&
         projectConfig?.projectConfig &&
         projectConfig?.projectDir) {
         return {
             appIdToMigrate,
+            isThemesMigration: hasMigratableThemes,
             projectName: projectConfig.projectConfig.name,
             projectDest: projectConfig.projectDir,
         };
@@ -179,12 +231,34 @@ export async function handleMigrationSetup(derivedAccountId, options, projectCon
         }));
     return { appIdToMigrate, projectName, projectDest };
 }
-export async function beginMigration(derivedAccountId, appId, platformVersion) {
+export async function handleThemesMigration(projectConfig, platformVersion) {
+    if (!projectConfig?.projectDir || !projectConfig?.projectConfig?.srcDir) {
+        throw new Error(lib.migrate.errors.project.invalidConfig);
+    }
+    const projectSrcDir = path.resolve(projectConfig.projectDir, projectConfig.projectConfig.srcDir);
+    try {
+        await migrateThemes(projectConfig.projectDir, projectSrcDir);
+    }
+    catch (error) {
+        debugError(error);
+        throw new Error(lib.migrate.errors.project.failedToMigrateThemes);
+    }
+    const newProjectConfig = { ...projectConfig.projectConfig };
+    newProjectConfig.platformVersion = platformVersion;
+    const projectConfigPath = path.join(projectConfig.projectDir, PROJECT_CONFIG_FILE);
+    const success = writeProjectConfig(projectConfigPath, newProjectConfig);
+    if (!success) {
+        throw new Error(lib.migrate.errors.project.failedToUpdateProjectConfig);
+    }
+    uiLogger.log('');
+    uiLogger.log(lib.migrate.success.themesMigrationSuccess(platformVersion));
+}
+export async function beginAppMigration(derivedAccountId, appId, platformVersion) {
     SpinniesManager.add('beginningMigration', {
         text: lib.migrate.spinners.beginningMigration,
     });
     const uidMap = {};
-    const { data } = await initializeMigration(derivedAccountId, appId, platformVersion);
+    const { data } = await initializeAppMigration(derivedAccountId, appId, platformVersion);
     const { migrationId } = data;
     let pollResponse;
     try {
@@ -247,13 +321,13 @@ export async function pollMigrationStatus(derivedAccountId, migrationId, success
         errorStates: [...DEFAULT_POLLING_STATUS_LOOKUP.errorStates],
     });
 }
-export async function finalizeMigration(derivedAccountId, migrationId, uidMap, projectName) {
+export async function finalizeAppMigration(derivedAccountId, migrationId, uidMap, projectName) {
     let pollResponse;
     try {
         SpinniesManager.add('finishingMigration', {
             text: lib.migrate.spinners.finishingMigration,
         });
-        await continueMigration(derivedAccountId, migrationId, uidMap, projectName);
+        await continueAppMigration(derivedAccountId, migrationId, uidMap, projectName);
         pollResponse = await pollMigrationStatus(derivedAccountId, migrationId, [
             MIGRATION_STATUS.SUCCESS,
         ]);
@@ -307,7 +381,7 @@ export async function downloadProjectFiles(derivedAccountId, projectName, buildI
         SpinniesManager.succeed('fetchingMigratedProject', {
             text: lib.migrate.spinners.downloadingProjectContentsComplete,
         });
-        uiLogger.success(`Saved ${projectName} to ${projectDest}`);
+        uiLogger.success(lib.migrate.success.downloadedProject(projectName, projectDest));
     }
     catch (error) {
         SpinniesManager.fail('fetchingMigratedProject', {
@@ -318,7 +392,7 @@ export async function downloadProjectFiles(derivedAccountId, projectName, buildI
 }
 export async function migrateApp2025_2(derivedAccountId, options, projectConfig) {
     SpinniesManager.init();
-    const ungatedForUnifiedApps = await hasFeature(derivedAccountId, FEATURES.UNIFIED_APPS);
+    const ungatedForUnifiedApps = await hasUnfiedAppsAccess(derivedAccountId);
     if (!ungatedForUnifiedApps) {
         throw new Error(lib.migrate.errors.notUngatedForUnifiedApps(uiAccountDescription(derivedAccountId)));
     }
@@ -331,16 +405,20 @@ export async function migrateApp2025_2(derivedAccountId, options, projectConfig)
             throw new Error(lib.migrate.errors.project.doesNotExist(derivedAccountId));
         }
     }
-    const { appIdToMigrate, projectName, projectDest } = await handleMigrationSetup(derivedAccountId, options, projectConfig);
+    const { appIdToMigrate, projectName, projectDest, isThemesMigration } = await handleMigrationSetup(derivedAccountId, options, projectConfig);
+    if (isThemesMigration) {
+        await handleThemesMigration(projectConfig, options.platformVersion);
+        return;
+    }
     if (!appIdToMigrate || !projectName || !projectDest) {
         return;
     }
-    const migrationInProgress = await beginMigration(derivedAccountId, appIdToMigrate, options.platformVersion);
+    const migrationInProgress = await beginAppMigration(derivedAccountId, appIdToMigrate, options.platformVersion);
     if (!migrationInProgress) {
         return;
     }
     const { migrationId, uidMap } = migrationInProgress;
-    const buildId = await finalizeMigration(derivedAccountId, migrationId, uidMap, projectConfig?.projectConfig?.name || projectName);
+    const buildId = await finalizeAppMigration(derivedAccountId, migrationId, uidMap, projectConfig?.projectConfig?.name || projectName);
     await downloadProjectFiles(derivedAccountId, projectName, buildId, projectDest, projectConfig);
     uiLogger.log(uiLink('Project Details', getProjectDetailUrl(projectName, derivedAccountId)));
     uiLogger.log(uiLink('Build Details', getProjectBuildDetailUrl(projectName, buildId, derivedAccountId)));

package/lib/constants.d.ts

@@ -87,6 +87,7 @@ export declare const LOCAL_DEV_UI_MESSAGE_SEND_TYPES: {
     UPDATE_PROJECT_NODES: string;
     UPDATE_APP_DATA: string;
     UPDATE_PROJECT_DATA: string;
+    UPDATE_UPLOAD_WARNINGS: string;
 };
 export declare const LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES: {
     UPLOAD: string;

package/lib/constants.js

@@ -79,6 +79,7 @@ export const LOCAL_DEV_UI_MESSAGE_SEND_TYPES = {
     UPDATE_PROJECT_NODES: 'server:updateProjectNodes',
     UPDATE_APP_DATA: 'server:updateAppData',
     UPDATE_PROJECT_DATA: 'server:updateProjectData',
+    UPDATE_UPLOAD_WARNINGS: 'server:updateUploadWarnings',
 };
 export const LOCAL_DEV_UI_MESSAGE_RECEIVE_TYPES = {
     UPLOAD: 'client:upload',