@hubspot/cli 7.8.0-experimental.0 → 7.8.0

package/lib/sandboxes.js

@@ -1,4 +1,3 @@
-import { logger } from '@hubspot/local-dev-lib/logger';
 import { getSandboxUsageLimits } from '@hubspot/local-dev-lib/api/sandboxHubs';
 import { fetchTypes } from '@hubspot/local-dev-lib/api/sandboxSync';
 import { getAccountId, getConfigAccounts } from '@hubspot/local-dev-lib/config';
@@ -6,9 +5,10 @@ import { getHubSpotWebsiteOrigin } from '@hubspot/local-dev-lib/urls';
 import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
 import { getAccountIdentifier } from '@hubspot/local-dev-lib/config/getAccountIdentifier';
 import { isMissingScopeError, isSpecifiedError, } from '@hubspot/local-dev-lib/errors/index';
-import { i18n } from './lang.js';
-import { uiAccountDescription } from './ui/index.js';
+import { uiLogger } from './ui/logger.js';
+import { lib } from '../lang/en.js';
 import { logError } from './errorHandlers/index.js';
+import { uiAccountDescription } from './ui/index.js';
 export const SYNC_TYPES = {
     OBJECT_RECORDS: 'object-records',
 };
@@ -54,11 +54,11 @@ export async function getAvailableSyncTypes(parentAccountConfig, config) {
     const id = getAccountIdentifier(config);
     const portalId = getAccountId(id);
     if (!parentPortalId || !portalId) {
-        throw new Error(i18n(`lib.sandbox.sync.failure.syncTypeFetch`));
+        throw new Error(lib.sandbox.sync.failure.syncTypeFetch);
     }
     const { data: { results: syncTypes }, } = await fetchTypes(parentPortalId, portalId);
     if (!syncTypes) {
-        throw new Error(i18n(`lib.sandbox.sync.failure.syncTypeFetch`));
+        throw new Error(lib.sandbox.sync.failure.syncTypeFetch);
     }
     return syncTypes.map(t => ({ type: t.name }));
 }
@@ -66,91 +66,63 @@ export async function validateSandboxUsageLimits(accountConfig, sandboxType, env
     const id = getAccountIdentifier(accountConfig);
     const accountId = getAccountId(id);
     if (!accountId) {
-        throw new Error(i18n(`lib.sandbox.create.failure.usageLimitFetch`));
+        throw new Error(lib.sandbox.create.failure.usageLimitsFetch);
     }
     const { data: { usage }, } = await getSandboxUsageLimits(accountId);
     if (!usage) {
-        throw new Error(i18n(`lib.sandbox.create.failure.usageLimitFetch`));
+        throw new Error(lib.sandbox.create.failure.usageLimitsFetch);
     }
     if (sandboxType === HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX) {
         if (usage['DEVELOPER'].available === 0) {
             const devSandboxLimit = usage['DEVELOPER'].limit;
-            const plural = devSandboxLimit !== 1;
             const hasDevelopmentSandboxes = getHasSandboxesByType(accountConfig, HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX);
             if (hasDevelopmentSandboxes) {
-                throw new Error(i18n(`lib.sandbox.create.failure.alreadyInConfig.developer.${plural ? 'other' : 'one'}`, {
-                    accountName: accountConfig.name || accountId,
-                    limit: devSandboxLimit,
-                }));
+                throw new Error(lib.sandbox.create.developer.failure.alreadyInConfig(accountId, devSandboxLimit));
             }
             else {
                 const baseUrl = getHubSpotWebsiteOrigin(env);
-                throw new Error(i18n(`lib.sandbox.create.failure.limit.developer.${plural ? 'other' : 'one'}`, {
-                    accountName: accountConfig.name || accountId,
-                    limit: devSandboxLimit,
-                    link: `${baseUrl}/sandboxes-developer/${accountId}/development`,
-                }));
+                throw new Error(lib.sandbox.create.developer.failure.limit(accountId, devSandboxLimit, `${baseUrl}/sandboxes-developer/${accountId}/development`));
             }
         }
     }
     if (sandboxType === HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX) {
         if (usage['STANDARD'].available === 0) {
             const standardSandboxLimit = usage['STANDARD'].limit;
-            const plural = standardSandboxLimit !== 1;
             const hasStandardSandboxes = getHasSandboxesByType(accountConfig, HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX);
             if (hasStandardSandboxes) {
-                throw new Error(i18n(`lib.sandbox.create.failure.alreadyInConfig.standard.${plural ? 'other' : 'one'}`, {
-                    accountName: accountConfig.name || accountId,
-                    limit: standardSandboxLimit,
-                }));
+                throw new Error(lib.sandbox.create.standard.failure.alreadyInConfig(accountId, standardSandboxLimit));
             }
             else {
                 const baseUrl = getHubSpotWebsiteOrigin(env);
-                throw new Error(i18n(`lib.sandbox.create.failure.limit.standard.${plural ? 'other' : 'one'}`, {
-                    accountName: accountConfig.name || accountId,
-                    limit: standardSandboxLimit,
-                    link: `${baseUrl}/sandboxes-developer/${accountId}/standard`,
-                }));
+                throw new Error(lib.sandbox.create.standard.failure.limit(accountId, standardSandboxLimit, `${baseUrl}/sandboxes-developer/${accountId}/standard`));
             }
         }
     }
 }
 export function handleSandboxCreateError(err, env, name, accountId) {
     if (isMissingScopeError(err)) {
-        logger.error(i18n(`lib.sandbox.create.failure.scopes.message`, {
-            accountName: uiAccountDescription(accountId),
-        }));
+        uiLogger.error(lib.sandbox.create.failure.scopes.message);
         const websiteOrigin = getHubSpotWebsiteOrigin(env);
         const url = `${websiteOrigin}/personal-access-key/${accountId}`;
-        logger.info(i18n(`lib.sandbox.create.failure.scopes.instructions`, {
-            accountName: uiAccountDescription(accountId),
-            url,
-        }));
+        uiLogger.info(lib.sandbox.create.failure.scopes.instructions(uiAccountDescription(accountId), url));
     }
     else if (isSpecifiedError(err, {
         statusCode: 403,
         category: 'BANNED',
         subCategory: 'SandboxErrors.USER_ACCESS_NOT_ALLOWED',
     })) {
-        logger.log('');
-        logger.error(i18n(`lib.sandbox.create.failure.invalidUser`, {
-            accountName: name,
-            parentAccountName: uiAccountDescription(accountId),
-        }));
-        logger.log('');
+        uiLogger.log('');
+        uiLogger.error(lib.sandbox.create.failure.invalidUser(name, accountId));
+        uiLogger.log('');
     }
     else if (isSpecifiedError(err, {
         statusCode: 403,
         category: 'BANNED',
         subCategory: 'SandboxErrors.DEVELOPMENT_SANDBOX_ACCESS_NOT_ALLOWED',
     })) {
-        logger.log('');
-        logger.error(i18n(`lib.sandbox.create.failure.403Gating`, {
-            accountName: name,
-            parentAccountName: uiAccountDescription(accountId),
-            accountId,
-        }));
-        logger.log('');
+        uiLogger.log('');
+        uiLogger.error(lib.sandbox.create.failure['403Gating'](name, accountId));
+        uiLogger.log('');
     }
     else {
         logError(err);

package/lib/schema.js

@@ -1,13 +1,13 @@
 import chalk from 'chalk';
 import { table, getBorderCharacters } from 'table';
-import { logger } from '@hubspot/local-dev-lib/logger';
 import { fetchObjectSchemas } from '@hubspot/local-dev-lib/api/customObjects';
+import { uiLogger } from './ui/logger.js';
 export function logSchemas(schemas) {
     const data = schemas
         .map(r => [r.labels.singular, r.name, r.objectTypeId || ''])
         .sort((a, b) => (a[1] > b[1] ? 1 : -1));
     if (data.length === 0) {
-        logger.log('No Schemas were found');
+        uiLogger.log('No Schemas were found');
         return;
     }
     data.unshift([
@@ -19,7 +19,7 @@ export function logSchemas(schemas) {
         singleLine: true,
         border: getBorderCharacters('honeywell'),
     };
-    logger.log(table(data, tableConfig));
+    uiLogger.log(table(data, tableConfig));
 }
 export async function listSchemas(accountId) {
     const { data } = await fetchObjectSchemas(accountId);

package/lib/serverlessLogs.js

@@ -1,6 +1,6 @@
 import https from 'https';
 import chalk from 'chalk';
-import { logger } from '@hubspot/local-dev-lib/logger';
+import { uiLogger } from './ui/logger.js';
 import { isHubSpotHttpError, isMissingScopeError, } from '@hubspot/local-dev-lib/errors/index';
 import { SCOPE_GROUPS, PERSONAL_ACCESS_KEY_AUTH_METHOD, } from '@hubspot/local-dev-lib/constants/auth';
 import { getAccountConfig } from '@hubspot/local-dev-lib/config';
@@ -10,7 +10,7 @@ import { logError, ApiErrorContext } from './errorHandlers/index.js';
 import SpinniesManager from './ui/SpinniesManager.js';
 import { handleExit, handleKeypress } from './process.js';
 import { EXIT_CODES } from './enums/exitCodes.js';
-import { i18n } from './lang.js';
+import { lib } from '../lang/en.js';
 const TAIL_DELAY = 5000;
 function base64EncodeString(valueToEncode) {
     if (typeof valueToEncode !== 'string') {
@@ -47,22 +47,20 @@ async function verifyAccessKeyAndUserAccess(accountId, scopeGroup) {
         scopesData = resp.data;
     }
     catch (e) {
-        logger.debug(i18n(`lib.serverless.verifyAccessKeyAndUserAccess.fetchScopeDataError`, {
-            scopeGroup,
-        }));
-        logger.debug(e);
+        uiLogger.debug(lib.serverless.verifyAccessKeyAndUserAccess.fetchScopeDataError(scopeGroup));
+        uiLogger.debug(e);
         return;
     }
     const { portalScopesInGroup, userScopesInGroup } = scopesData;
     if (!portalScopesInGroup.length) {
-        logger.error(i18n(`lib.serverless.verifyAccessKeyAndUserAccess.portalMissingScope`));
+        uiLogger.error(lib.serverless.verifyAccessKeyAndUserAccess.portalMissingScope);
         return;
     }
     if (!portalScopesInGroup.every(s => userScopesInGroup.includes(s))) {
-        logger.error(i18n(`lib.serverless.verifyAccessKeyAndUserAccess.userMissingScope`));
+        uiLogger.error(lib.serverless.verifyAccessKeyAndUserAccess.userMissingScope);
     }
     else {
-        logger.error(i18n(`lib.serverless.verifyAccessKeyAndUserAccess.genericMissingScope`));
+        uiLogger.error(lib.serverless.verifyAccessKeyAndUserAccess.genericMissingScope);
     }
 }
 export async function tailLogs(accountId, name, fetchLatest, tailCall, compact = false) {
@@ -120,7 +118,7 @@ export async function tailLogs(accountId, name, fetchLatest, tailCall, compact =
 }
 export async function outputBuildLog(buildLogUrl) {
     if (!buildLogUrl) {
-        logger.debug('Unable to display build output. No build log URL was provided.');
+        uiLogger.debug('Unable to display build output. No build log URL was provided.');
         return '';
     }
     return new Promise(resolve => {
@@ -135,16 +133,16 @@ export async function outputBuildLog(buildLogUrl) {
                     data += chunk;
                 });
                 response.on('end', () => {
-                    logger.log(data);
+                    uiLogger.log(data);
                     resolve(data);
                 });
             })
                 .on('error', () => {
-                logger.error('The build log could not be retrieved.');
+                uiLogger.error('The build log could not be retrieved.');
             });
         }
         catch (e) {
-            logger.error('The build log could not be retrieved.');
+            uiLogger.error('The build log could not be retrieved.');
             resolve('');
         }
     });

package/lib/theme/__tests__/migrate.test.d.ts

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

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

@@ -0,0 +1,233 @@
+import { getProjectThemeDetails, migrateThemes, } from '@hubspot/project-parsing-lib';
+import { confirmPrompt } from '../../prompts/promptUtils.js';
+import { writeProjectConfig, } from '../../projects/config.js';
+import { ensureProjectExists } from '../../projects/ensureProjectExists.js';
+import { isV2Project } from '../../projects/platformVersion.js';
+import { fetchMigrationApps } from '../../app/migrate.js';
+import { getHasMigratableThemes, validateMigrationAppsAndThemes, handleThemesMigration, migrateThemes2025_2, } from '../migrate.js';
+import { lib } from '../../../lang/en.js';
+vi.mock('../../ui/logger.js');
+vi.mock('@hubspot/project-parsing-lib');
+vi.mock('../../prompts/promptUtils');
+vi.mock('../../projects/config');
+vi.mock('../../projects/ensureProjectExists');
+vi.mock('../../projects/platformVersion');
+vi.mock('../../app/migrate');
+const mockedGetProjectThemeDetails = getProjectThemeDetails;
+const mockedMigrateThemes = migrateThemes;
+const mockedConfirmPrompt = confirmPrompt;
+const mockedWriteProjectConfig = writeProjectConfig;
+const mockedEnsureProjectExists = ensureProjectExists;
+const mockedUseV2Api = isV2Project;
+const mockedFetchMigrationApps = fetchMigrationApps;
+const ACCOUNT_ID = 123;
+const PROJECT_NAME = 'Test Project';
+const PLATFORM_VERSION = '2025.2';
+const MOCK_PROJECT_DIR = '/mock/project/dir';
+const createLoadedProjectConfig = (name) => ({
+    projectConfig: { name, srcDir: 'src', platformVersion: '2024.1' },
+    projectDir: MOCK_PROJECT_DIR,
+});
+describe('lib/theme/migrate', () => {
+    beforeEach(() => {
+        mockedUseV2Api.mockReturnValue(false);
+    });
+    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 false when projectConfig is missing required properties', async () => {
+            const invalidProjectConfig = {
+                projectConfig: { name: undefined, srcDir: 'src' },
+                projectDir: undefined,
+            };
+            const result = await getHasMigratableThemes(invalidProjectConfig);
+            expect(result).toEqual({
+                hasMigratableThemes: false,
+                migratableThemesCount: 0,
+            });
+        });
+        it('should return true when there are legacy 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,
+            });
+        });
+        it('should return true when there are legacy React themes', async () => {
+            mockedGetProjectThemeDetails.mockResolvedValue({
+                legacyThemeDetails: [],
+                legacyReactThemeDetails: [
+                    {
+                        configFilepath: 'src/react-theme.json',
+                        themePath: 'src/react-theme',
+                        themeConfig: {
+                            secretNames: ['my-secret'],
+                        },
+                    },
+                ],
+            });
+            const projectConfig = createLoadedProjectConfig(PROJECT_NAME);
+            const result = await getHasMigratableThemes(projectConfig);
+            expect(result).toEqual({
+                hasMigratableThemes: true,
+                migratableThemesCount: 1,
+            });
+        });
+        it('should return true when there are both legacy and React themes', async () => {
+            mockedGetProjectThemeDetails.mockResolvedValue({
+                legacyThemeDetails: [
+                    {
+                        configFilepath: 'src/theme.json',
+                        themePath: 'src/theme',
+                        themeConfig: {
+                            secret_names: ['my-secret'],
+                        },
+                    },
+                ],
+                legacyReactThemeDetails: [
+                    {
+                        configFilepath: 'src/react-theme.json',
+                        themePath: 'src/react-theme',
+                        themeConfig: {
+                            secretNames: ['my-secret'],
+                        },
+                    },
+                ],
+            });
+            const projectConfig = createLoadedProjectConfig(PROJECT_NAME);
+            const result = await getHasMigratableThemes(projectConfig);
+            expect(result).toEqual({
+                hasMigratableThemes: true,
+                migratableThemesCount: 2,
+            });
+        });
+    });
+    describe('validateMigrationAppsAndThemes', () => {
+        it('should throw an error when themes are already migrated (v2 API)', async () => {
+            mockedUseV2Api.mockReturnValue(true);
+            const projectConfig = createLoadedProjectConfig(PROJECT_NAME);
+            await expect(validateMigrationAppsAndThemes(0, projectConfig)).rejects.toThrow(lib.migrate.errors.project.themesAlreadyMigrated);
+        });
+        it('should throw an error when apps and themes are both present', async () => {
+            const projectConfig = createLoadedProjectConfig(PROJECT_NAME);
+            await expect(validateMigrationAppsAndThemes(1, projectConfig)).rejects.toThrow(lib.migrate.errors.project.themesAndAppsNotAllowed);
+        });
+        it('should throw an error when no project config is provided', async () => {
+            await expect(validateMigrationAppsAndThemes(0)).rejects.toThrow(lib.migrate.errors.project.noProjectForThemesMigration);
+        });
+        it('should not throw an error when validation passes', async () => {
+            const projectConfig = createLoadedProjectConfig(PROJECT_NAME);
+            await expect(validateMigrationAppsAndThemes(0, projectConfig)).resolves.not.toThrow();
+        });
+    });
+    describe('handleThemesMigration', () => {
+        const projectConfig = createLoadedProjectConfig(PROJECT_NAME);
+        beforeEach(() => {
+            mockedMigrateThemes.mockResolvedValue({
+                migrated: true,
+                failureReason: undefined,
+                legacyThemeDetails: [],
+                legacyReactThemeDetails: [],
+            });
+            mockedWriteProjectConfig.mockReturnValue(true);
+        });
+        it('should throw an error when project config is invalid', async () => {
+            const invalidProjectConfig = {
+                projectConfig: { name: PROJECT_NAME, srcDir: undefined },
+                projectDir: undefined,
+            };
+            await expect(handleThemesMigration(invalidProjectConfig, PLATFORM_VERSION)).rejects.toThrow(lib.migrate.errors.project.invalidConfig);
+        });
+        it('should successfully migrate themes and update project config', async () => {
+            await handleThemesMigration(projectConfig, PLATFORM_VERSION);
+            expect(mockedMigrateThemes).toHaveBeenCalledWith(MOCK_PROJECT_DIR, `${MOCK_PROJECT_DIR}/src`);
+            expect(mockedWriteProjectConfig).toHaveBeenCalledWith(`${MOCK_PROJECT_DIR}/hsproject.json`, expect.objectContaining({
+                platformVersion: PLATFORM_VERSION,
+            }));
+        });
+        it('should throw an error when theme migration fails', async () => {
+            mockedMigrateThemes.mockResolvedValue({
+                migrated: false,
+                failureReason: 'Migration failed',
+                legacyThemeDetails: [],
+                legacyReactThemeDetails: [],
+            });
+            await expect(handleThemesMigration(projectConfig, PLATFORM_VERSION)).rejects.toThrow('Migration failed');
+        });
+        it('should throw an error when project config write fails', async () => {
+            mockedWriteProjectConfig.mockReturnValue(false);
+            await expect(handleThemesMigration(projectConfig, PLATFORM_VERSION)).rejects.toThrow(lib.migrate.errors.project.failedToUpdateProjectConfig);
+        });
+        it('should throw an error when migrateThemes throws an exception', async () => {
+            mockedMigrateThemes.mockRejectedValue(new Error('Unexpected error'));
+            await expect(handleThemesMigration(projectConfig, PLATFORM_VERSION)).rejects.toThrow(lib.migrate.errors.project.failedToMigrateThemes);
+        });
+    });
+    describe('migrateThemes2025_2', () => {
+        const options = {
+            platformVersion: PLATFORM_VERSION,
+        };
+        const projectConfig = createLoadedProjectConfig(PROJECT_NAME);
+        const themeCount = 2;
+        beforeEach(() => {
+            mockedEnsureProjectExists.mockResolvedValue({ projectExists: true });
+            mockedFetchMigrationApps.mockResolvedValue({
+                migratableApps: [],
+                unmigratableApps: [],
+            });
+            mockedConfirmPrompt.mockResolvedValue(true);
+            mockedMigrateThemes.mockResolvedValue({
+                migrated: true,
+                failureReason: undefined,
+                legacyThemeDetails: [],
+                legacyReactThemeDetails: [],
+            });
+            mockedWriteProjectConfig.mockReturnValue(true);
+        });
+        it('should throw an error when project config is invalid', async () => {
+            const invalidProjectConfig = {
+                projectConfig: undefined,
+                projectDir: MOCK_PROJECT_DIR,
+            };
+            await expect(migrateThemes2025_2(ACCOUNT_ID, options, themeCount, invalidProjectConfig)).rejects.toThrow(lib.migrate.errors.project.invalidConfig);
+        });
+        it('should throw an error when project does not exist', async () => {
+            mockedEnsureProjectExists.mockResolvedValue({ projectExists: false });
+            await expect(migrateThemes2025_2(ACCOUNT_ID, options, themeCount, projectConfig)).rejects.toThrow(lib.migrate.errors.project.doesNotExist(ACCOUNT_ID));
+        });
+        it('should proceed with migration when user confirms', async () => {
+            await migrateThemes2025_2(ACCOUNT_ID, options, themeCount, projectConfig);
+            expect(mockedFetchMigrationApps).toHaveBeenCalledWith(ACCOUNT_ID, PLATFORM_VERSION, projectConfig);
+            expect(mockedConfirmPrompt).toHaveBeenCalledWith(lib.migrate.prompt.proceed, { defaultAnswer: false });
+            expect(mockedMigrateThemes).toHaveBeenCalledWith(MOCK_PROJECT_DIR, `${MOCK_PROJECT_DIR}/src`);
+        });
+        it('should exit without migrating when user cancels', async () => {
+            mockedConfirmPrompt.mockResolvedValue(false);
+            await migrateThemes2025_2(ACCOUNT_ID, options, themeCount, projectConfig);
+            expect(mockedMigrateThemes).not.toHaveBeenCalled();
+        });
+        it('should validate migration apps and themes', async () => {
+            await migrateThemes2025_2(ACCOUNT_ID, options, themeCount, projectConfig);
+            // The validation is called internally, so we verify it through the error handling
+            expect(mockedFetchMigrationApps).toHaveBeenCalled();
+        });
+    });
+});

package/lib/theme/migrate.d.ts

@@ -0,0 +1,13 @@
+import { ArgumentsCamelCase } from 'yargs';
+import { LoadedProjectConfig } from '../projects/config.js';
+import { AccountArgs, CommonArgs, ConfigArgs, EnvironmentArgs } from '../../types/Yargs.js';
+export type MigrateThemesArgs = CommonArgs & AccountArgs & EnvironmentArgs & ConfigArgs & {
+    platformVersion: string;
+};
+export declare function getHasMigratableThemes(projectConfig?: LoadedProjectConfig): Promise<{
+    hasMigratableThemes: boolean;
+    migratableThemesCount: number;
+}>;
+export declare function validateMigrationAppsAndThemes(hasApps: number, projectConfig?: LoadedProjectConfig): Promise<void>;
+export declare function handleThemesMigration(projectConfig: LoadedProjectConfig, platformVersion: string): Promise<void>;
+export declare function migrateThemes2025_2(derivedAccountId: number, options: ArgumentsCamelCase<MigrateThemesArgs>, themeCount: number, projectConfig: LoadedProjectConfig): Promise<void>;

package/lib/theme/migrate.js

@@ -0,0 +1,90 @@
+import path from 'path';
+import { migrateThemes, getProjectThemeDetails, } from '@hubspot/project-parsing-lib';
+import { writeProjectConfig } from '../projects/config.js';
+import { ensureProjectExists } from '../projects/ensureProjectExists.js';
+import SpinniesManager from '../ui/SpinniesManager.js';
+import { lib } from '../../lang/en.js';
+import { PROJECT_CONFIG_FILE } from '../constants.js';
+import { uiLogger } from '../ui/logger.js';
+import { debugError } from '../errorHandlers/index.js';
+import { isV2Project } from '../projects/platformVersion.js';
+import { confirmPrompt } from '../prompts/promptUtils.js';
+import { fetchMigrationApps } from '../app/migrate.js';
+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 validateMigrationAppsAndThemes(hasApps, projectConfig) {
+    if (isV2Project(projectConfig?.projectConfig?.platformVersion)) {
+        throw new Error(lib.migrate.errors.project.themesAlreadyMigrated);
+    }
+    if (hasApps > 0 && projectConfig) {
+        throw new Error(lib.migrate.errors.project.themesAndAppsNotAllowed);
+    }
+    if (!projectConfig) {
+        throw new Error(lib.migrate.errors.project.noProjectForThemesMigration);
+    }
+}
+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);
+    let migrated = false;
+    let failureReason;
+    try {
+        const migrationResult = await migrateThemes(projectConfig.projectDir, projectSrcDir);
+        migrated = migrationResult.migrated;
+        failureReason = migrationResult.failureReason;
+    }
+    catch (error) {
+        debugError(error);
+        throw new Error(lib.migrate.errors.project.failedToMigrateThemes);
+    }
+    if (!migrated) {
+        throw new Error(failureReason || 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 migrateThemes2025_2(derivedAccountId, options, themeCount, projectConfig) {
+    SpinniesManager.init();
+    if (!projectConfig?.projectConfig || !projectConfig?.projectDir) {
+        throw new Error(lib.migrate.errors.project.invalidConfig);
+    }
+    const { projectExists } = await ensureProjectExists(derivedAccountId, projectConfig.projectConfig.name, { allowCreate: false, noLogs: true });
+    if (!projectExists) {
+        throw new Error(lib.migrate.errors.project.doesNotExist(derivedAccountId));
+    }
+    SpinniesManager.add('checkingForMigratableComponents', {
+        text: lib.migrate.spinners.checkingForMigratableComponents,
+    });
+    const { migratableApps, unmigratableApps } = await fetchMigrationApps(derivedAccountId, options.platformVersion, projectConfig);
+    const hasApps = [...migratableApps, ...unmigratableApps].length;
+    SpinniesManager.remove('checkingForMigratableComponents');
+    await validateMigrationAppsAndThemes(hasApps, projectConfig);
+    uiLogger.log(lib.migrate.prompt.themesMigration(themeCount));
+    const proceed = await confirmPrompt(lib.migrate.prompt.proceed, {
+        defaultAnswer: false,
+    });
+    if (proceed) {
+        await handleThemesMigration(projectConfig, options.platformVersion);
+    }
+    else {
+        uiLogger.log(lib.migrate.exitWithoutMigrating);
+    }
+}

package/lib/ui/SpinniesManager.d.ts

@@ -3,6 +3,7 @@ interface SpinnerState extends BaseSpinnerOptions {
     name?: string;
 }
 declare class SpinniesManager {
+    private disableOutput;
     private options;
     private spinners;
     private isCursorHidden;
@@ -14,6 +15,7 @@ declare class SpinniesManager {
     constructor();
     init(options?: Partial<SpinnerState>): void;
     private resetState;
+    setDisableOutput(disableOutput: boolean): void;
     pick(name: string): SpinnerState | undefined;
     add(name: string, options?: Partial<SpinnerState>): SpinnerState & {
         name: string;