@hubspot/cli 7.6.0-beta.1 → 7.6.0-beta.10

package/lib/app/migrate.d.ts

@@ -1,7 +1,7 @@
 import { ArgumentsCamelCase } from 'yargs';
-import { LoadedProjectConfig } from '../projects/config';
-import { MigrationApp, MigrationFailed, MigrationStatus } from '../../api/migrate';
-import { AccountArgs, CommonArgs, ConfigArgs, EnvironmentArgs } from '../../types/Yargs';
+import { LoadedProjectConfig } from '../projects/config.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;
     dest?: 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

@@ -1,60 +1,45 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getUnmigratableReason = getUnmigratableReason;
-exports.generateFilterAppsByProjectNameFunction = generateFilterAppsByProjectNameFunction;
-exports.buildErrorMessageFromMigrationStatus = buildErrorMessageFromMigrationStatus;
-exports.fetchMigrationApps = fetchMigrationApps;
-exports.promptForAppToMigrate = promptForAppToMigrate;
-exports.selectAppToMigrate = selectAppToMigrate;
-exports.handleMigrationSetup = handleMigrationSetup;
-exports.beginMigration = beginMigration;
-exports.pollMigrationStatus = pollMigrationStatus;
-exports.finalizeMigration = finalizeMigration;
-exports.downloadProjectFiles = downloadProjectFiles;
-exports.migrateApp2025_2 = migrateApp2025_2;
-exports.logInvalidAccountError = logInvalidAccountError;
-const path_1 = __importDefault(require("path"));
-const path_2 = require("@hubspot/local-dev-lib/path");
-const archive_1 = require("@hubspot/local-dev-lib/archive");
-const chalk_1 = __importDefault(require("chalk"));
-const project_parsing_lib_1 = require("@hubspot/project-parsing-lib");
-const projects_1 = require("@hubspot/local-dev-lib/constants/projects");
-const transform_1 = require("@hubspot/project-parsing-lib/src/lib/transform");
-const Migration_1 = require("@hubspot/local-dev-lib/types/Migration");
-const projects_2 = require("@hubspot/local-dev-lib/api/projects");
-const inquirer = require('inquirer');
-const promptUtils_1 = require("../prompts/promptUtils");
-const ui_1 = require("../ui");
-const ensureProjectExists_1 = require("../projects/ensureProjectExists");
-const SpinniesManager_1 = __importDefault(require("../ui/SpinniesManager"));
-const polling_1 = require("../polling");
-const migrate_1 = require("../../api/migrate");
-const fs_1 = __importDefault(require("fs"));
-const en_1 = require("../../lang/en");
-const hasFeature_1 = require("../hasFeature");
-const constants_1 = require("../constants");
-const urls_1 = require("../projects/urls");
-const logger_1 = require("../ui/logger");
-function getUnmigratableReason(reasonCode, projectName, accountId) {
+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, 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';
+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, continueAppMigration, initializeAppMigration, isMigrationStatus, listAppsForMigration, } from '../../api/migrate.js';
+import fs from 'fs';
+import { lib } from '../../lang/en.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 projects_1.UNMIGRATABLE_REASONS.UP_TO_DATE:
-            return en_1.lib.migrate.errors.unmigratableReasons.upToDate;
-        case projects_1.UNMIGRATABLE_REASONS.IS_A_PRIVATE_APP:
-            return en_1.lib.migrate.errors.unmigratableReasons.isPrivateApp;
-        case projects_1.UNMIGRATABLE_REASONS.LISTED_IN_MARKETPLACE:
-            return en_1.lib.migrate.errors.unmigratableReasons.listedInMarketplace;
-        case projects_1.UNMIGRATABLE_REASONS.PROJECT_CONNECTED_TO_GITHUB:
-            return en_1.lib.migrate.errors.unmigratableReasons.projectConnectedToGitHub(projectName, accountId);
-        case migrate_1.CLI_UNMIGRATABLE_REASONS.PART_OF_PROJECT_ALREADY:
-            return en_1.lib.migrate.errors.unmigratableReasons.partOfProjectAlready;
+        case UNMIGRATABLE_REASONS.UP_TO_DATE:
+            return lib.migrate.errors.unmigratableReasons.upToDate;
+        case UNMIGRATABLE_REASONS.IS_A_PRIVATE_APP:
+            return lib.migrate.errors.unmigratableReasons.isPrivateApp;
+        case UNMIGRATABLE_REASONS.LISTED_IN_MARKETPLACE:
+            return lib.migrate.errors.unmigratableReasons.listedInMarketplace;
+        case UNMIGRATABLE_REASONS.PROJECT_CONNECTED_TO_GITHUB:
+            return lib.migrate.errors.unmigratableReasons.projectConnectedToGitHub(projectName, accountId);
+        case CLI_UNMIGRATABLE_REASONS.PART_OF_PROJECT_ALREADY:
+            return lib.migrate.errors.unmigratableReasons.partOfProjectAlready;
         default:
-            return en_1.lib.migrate.errors.unmigratableReasons.generic(reasonCode);
+            return lib.migrate.errors.unmigratableReasons.generic(reasonCode);
     }
 }
-function generateFilterAppsByProjectNameFunction(projectConfig) {
+export function generateFilterAppsByProjectNameFunction(projectConfig) {
     return (app) => {
         if (projectConfig) {
             return app.projectName === projectConfig?.projectConfig?.name;
@@ -62,7 +47,7 @@ function generateFilterAppsByProjectNameFunction(projectConfig) {
         return true;
     };
 }
-function buildErrorMessageFromMigrationStatus(error) {
+export function buildErrorMessageFromMigrationStatus(error) {
     const { componentErrors, projectErrorDetail } = error;
     if (!componentErrors || !componentErrors.length) {
         return projectErrorDetail;
@@ -74,43 +59,71 @@ function buildErrorMessageFromMigrationStatus(error) {
     })
         .join('\n\t- ')}`;
 }
-async function fetchMigrationApps(appId, derivedAccountId, platformVersion, projectConfig) {
-    const { data: { migratableApps, unmigratableApps }, } = await (0, migrate_1.listAppsForMigration)(derivedAccountId, platformVersion);
+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(en_1.lib.migrate.errors.project.multipleApps);
+        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) {
                 app.isMigratable = false;
                 app.unmigratableReason =
-                    migrate_1.CLI_UNMIGRATABLE_REASONS.PART_OF_PROJECT_ALREADY;
+                    CLI_UNMIGRATABLE_REASONS.PART_OF_PROJECT_ALREADY;
             }
         });
     }
     if (allApps.length === 0 && projectConfig) {
-        throw new Error(en_1.lib.migrate.errors.noAppsForProject(projectConfig?.projectConfig?.name || ''));
+        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_1.default.bold(app.appName)}: ${getUnmigratableReason(app.unmigratableReason, app.projectName, derivedAccountId)}`);
-        throw new Error(en_1.lib.migrate.errors.noAppsEligible((0, ui_1.uiAccountDescription)(derivedAccountId), reasons));
+        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 &&
         !allApps.some(app => {
             return app.appId === appId;
         })) {
-        throw new Error(en_1.lib.migrate.errors.appWithAppIdNotFound(appId));
+        throw new Error(lib.migrate.errors.appWithAppIdNotFound(appId));
     }
-    return allApps;
 }
-async function promptForAppToMigrate(allApps, derivedAccountId) {
+export async function promptForAppToMigrate(allApps, derivedAccountId) {
     const appChoices = allApps.map(app => ({
         name: app.isMigratable
             ? app.appName
-            : `[${chalk_1.default.yellow('DISABLED')}] ${app.appName} `,
+            : `[${chalk.yellow('DISABLED')}] ${app.appName} `,
         value: app,
         disabled: app.isMigratable
             ? false
@@ -118,21 +131,17 @@ async function promptForAppToMigrate(allApps, derivedAccountId) {
     }));
     const enabledChoices = appChoices.filter(app => !app.disabled);
     const disabledChoices = appChoices.filter(app => app.disabled);
-    const { appId: selectedAppId } = await (0, promptUtils_1.listPrompt)(en_1.lib.migrate.prompt.chooseApp, {
-        choices: [
-            ...enabledChoices,
-            new inquirer.Separator(),
-            ...disabledChoices,
-        ],
+    const { appId: selectedAppId } = await listPrompt(lib.migrate.prompt.chooseApp, {
+        choices: [...enabledChoices, new Separator(), ...disabledChoices],
     });
     return selectedAppId;
 }
-async function selectAppToMigrate(allApps, derivedAccountId, appId) {
+export async function selectAppToMigrate(allApps, derivedAccountId, appId) {
     if (appId &&
         !allApps.some(app => {
             return app.appId === appId;
         })) {
-        throw new Error(en_1.lib.migrate.errors.appWithAppIdNotFound(appId));
+        throw new Error(lib.migrate.errors.appWithAppIdNotFound(appId));
     }
     let appIdToMigrate = appId;
     if (!appIdToMigrate) {
@@ -143,20 +152,20 @@ async function selectAppToMigrate(allApps, derivedAccountId, appId) {
     const unmigratableComponents = new Set();
     selectedApp?.migrationComponents.forEach(component => {
         if (component.isSupported) {
-            migratableComponents.add((0, transform_1.mapToUserFacingType)(component.componentType));
+            migratableComponents.add(mapToUserFacingType(component.componentType));
         }
         else {
-            unmigratableComponents.add((0, transform_1.mapToUserFacingType)(component.componentType));
+            unmigratableComponents.add(mapToUserFacingType(component.componentType));
         }
     });
     if (migratableComponents.size !== 0) {
-        logger_1.uiLogger.log(en_1.lib.migrate.componentsToBeMigrated(`\n - ${[...migratableComponents].join('\n - ')}`));
+        uiLogger.log(lib.migrate.componentsToBeMigrated(`\n - ${[...migratableComponents].join('\n - ')}`));
     }
     if (unmigratableComponents.size !== 0) {
-        logger_1.uiLogger.log(en_1.lib.migrate.componentsThatWillNotBeMigrated(`\n - ${[...unmigratableComponents].join('\n - ')}`));
+        uiLogger.log(lib.migrate.componentsThatWillNotBeMigrated(`\n - ${[...unmigratableComponents].join('\n - ')}`));
     }
-    logger_1.uiLogger.log('');
-    const proceed = await (0, promptUtils_1.confirmPrompt)(en_1.lib.migrate.prompt.proceed, {
+    uiLogger.log('');
+    const proceed = await confirmPrompt(lib.migrate.prompt.proceed, {
         defaultAnswer: false,
     });
     return {
@@ -164,75 +173,118 @@ async function selectAppToMigrate(allApps, derivedAccountId, appId) {
         appIdToMigrate,
     };
 }
-async function handleMigrationSetup(derivedAccountId, options, projectConfig) {
+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,
         };
     }
     const projectName = name ||
-        (await (0, promptUtils_1.inputPrompt)(en_1.lib.migrate.prompt.inputName, {
+        (await inputPrompt(lib.migrate.prompt.inputName, {
             validate: async (input) => {
-                const { projectExists } = await (0, ensureProjectExists_1.ensureProjectExists)(derivedAccountId, input, { allowCreate: false, noLogs: true });
+                const { projectExists } = await ensureProjectExists(derivedAccountId, input, { allowCreate: false, noLogs: true });
                 if (projectExists) {
-                    return en_1.lib.migrate.errors.project.alreadyExists(input);
+                    return lib.migrate.errors.project.alreadyExists(input);
                 }
                 return true;
             },
         }));
-    const { projectExists } = await (0, ensureProjectExists_1.ensureProjectExists)(derivedAccountId, projectName, { allowCreate: false, noLogs: true });
+    const { projectExists } = await ensureProjectExists(derivedAccountId, projectName, { allowCreate: false, noLogs: true });
     if (projectExists) {
-        throw new Error(en_1.lib.migrate.errors.project.alreadyExists(projectName));
+        throw new Error(lib.migrate.errors.project.alreadyExists(projectName));
     }
     const projectDest = dest ||
-        (await (0, promptUtils_1.inputPrompt)(en_1.lib.migrate.prompt.inputDest, {
-            defaultAnswer: path_1.default.resolve((0, path_2.getCwd)(), (0, path_2.sanitizeFileName)(projectName)),
+        (await inputPrompt(lib.migrate.prompt.inputDest, {
+            defaultAnswer: path.resolve(getCwd(), sanitizeFileName(projectName)),
         }));
     return { appIdToMigrate, projectName, projectDest };
 }
-async function beginMigration(derivedAccountId, appId, platformVersion) {
-    SpinniesManager_1.default.add('beginningMigration', {
-        text: en_1.lib.migrate.spinners.beginningMigration,
+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 (0, migrate_1.initializeMigration)(derivedAccountId, appId, platformVersion);
+    const { data } = await initializeAppMigration(derivedAccountId, appId, platformVersion);
     const { migrationId } = data;
     let pollResponse;
     try {
         pollResponse = await pollMigrationStatus(derivedAccountId, migrationId, [
-            Migration_1.MIGRATION_STATUS.INPUT_REQUIRED,
+            MIGRATION_STATUS.INPUT_REQUIRED,
         ]);
     }
     catch (error) {
-        SpinniesManager_1.default.fail('beginningMigration', {
-            text: en_1.lib.migrate.spinners.unableToStartMigration,
+        SpinniesManager.fail('beginningMigration', {
+            text: lib.migrate.spinners.unableToStartMigration,
         });
-        if ((0, migrate_1.isMigrationStatus)(error) && error.status === Migration_1.MIGRATION_STATUS.FAILURE) {
+        if (isMigrationStatus(error) && error.status === MIGRATION_STATUS.FAILURE) {
             throw new Error(buildErrorMessageFromMigrationStatus(error));
         }
-        throw new Error(en_1.lib.migrate.errors.migrationFailed, {
+        throw new Error(lib.migrate.errors.migrationFailed, {
             cause: error,
         });
     }
-    if (pollResponse.status !== Migration_1.MIGRATION_STATUS.INPUT_REQUIRED) {
-        SpinniesManager_1.default.fail('beginningMigration', {
-            text: en_1.lib.migrate.spinners.unableToStartMigration,
+    if (pollResponse.status !== MIGRATION_STATUS.INPUT_REQUIRED) {
+        SpinniesManager.fail('beginningMigration', {
+            text: lib.migrate.spinners.unableToStartMigration,
         });
         return;
     }
     const { componentsRequiringUids } = pollResponse;
-    SpinniesManager_1.default.remove('beginningMigration');
+    SpinniesManager.remove('beginningMigration');
     if (Object.values(componentsRequiringUids).length !== 0) {
         for (const [componentId, component] of Object.entries(componentsRequiringUids)) {
             const { componentHint, componentType } = component;
@@ -248,11 +300,11 @@ async function beginMigration(derivedAccountId, appId, platformVersion) {
                 internalId = componentId;
             }
             const promptText = componentHint
-                ? `${(0, transform_1.mapToUserFacingType)(componentType)} '${componentHint}' (ID: ${internalId})`
-                : `${(0, transform_1.mapToUserFacingType)(componentType)} (ID: ${internalId})`;
-            uidMap[componentId] = await (0, promptUtils_1.inputPrompt)(en_1.lib.migrate.prompt.uidForComponent(promptText), {
+                ? `${mapToUserFacingType(componentType)} '${componentHint}' (ID: ${internalId})`
+                : `${mapToUserFacingType(componentType)} (ID: ${internalId})`;
+            uidMap[componentId] = await inputPrompt(lib.migrate.prompt.uidForComponent(promptText), {
                 validate: (uid) => {
-                    const result = (0, project_parsing_lib_1.validateUid)(uid);
+                    const result = validateUid(uid);
                     return result === undefined ? true : result;
                 },
                 defaultAnswer: componentHint
@@ -263,113 +315,117 @@ async function beginMigration(derivedAccountId, appId, platformVersion) {
     }
     return { migrationId, uidMap };
 }
-async function pollMigrationStatus(derivedAccountId, migrationId, successStates = []) {
-    return (0, polling_1.poll)(() => (0, migrate_1.checkMigrationStatusV2)(derivedAccountId, migrationId), {
+export async function pollMigrationStatus(derivedAccountId, migrationId, successStates = []) {
+    return poll(() => checkMigrationStatusV2(derivedAccountId, migrationId), {
         successStates: [...successStates],
-        errorStates: [...polling_1.DEFAULT_POLLING_STATUS_LOOKUP.errorStates],
+        errorStates: [...DEFAULT_POLLING_STATUS_LOOKUP.errorStates],
     });
 }
-async function finalizeMigration(derivedAccountId, migrationId, uidMap, projectName) {
+export async function finalizeAppMigration(derivedAccountId, migrationId, uidMap, projectName) {
     let pollResponse;
     try {
-        SpinniesManager_1.default.add('finishingMigration', {
-            text: en_1.lib.migrate.spinners.finishingMigration,
+        SpinniesManager.add('finishingMigration', {
+            text: lib.migrate.spinners.finishingMigration,
         });
-        await (0, migrate_1.continueMigration)(derivedAccountId, migrationId, uidMap, projectName);
+        await continueAppMigration(derivedAccountId, migrationId, uidMap, projectName);
         pollResponse = await pollMigrationStatus(derivedAccountId, migrationId, [
-            Migration_1.MIGRATION_STATUS.SUCCESS,
+            MIGRATION_STATUS.SUCCESS,
         ]);
     }
     catch (error) {
-        SpinniesManager_1.default.fail('finishingMigration', {
-            text: en_1.lib.migrate.spinners.migrationFailed,
+        SpinniesManager.fail('finishingMigration', {
+            text: lib.migrate.spinners.migrationFailed,
         });
-        if ((0, migrate_1.isMigrationStatus)(error) && error.status === Migration_1.MIGRATION_STATUS.FAILURE) {
+        if (isMigrationStatus(error) && error.status === MIGRATION_STATUS.FAILURE) {
             throw new Error(buildErrorMessageFromMigrationStatus(error));
         }
-        throw new Error(en_1.lib.migrate.errors.migrationFailed, {
+        throw new Error(lib.migrate.errors.migrationFailed, {
             cause: error,
         });
     }
-    if (pollResponse.status !== Migration_1.MIGRATION_STATUS.SUCCESS) {
-        throw new Error(en_1.lib.migrate.errors.migrationFailed);
+    if (pollResponse.status !== MIGRATION_STATUS.SUCCESS) {
+        throw new Error(lib.migrate.errors.migrationFailed);
     }
-    if (pollResponse.status === Migration_1.MIGRATION_STATUS.SUCCESS) {
-        SpinniesManager_1.default.succeed('finishingMigration', {
-            text: en_1.lib.migrate.spinners.migrationComplete,
+    if (pollResponse.status === MIGRATION_STATUS.SUCCESS) {
+        SpinniesManager.succeed('finishingMigration', {
+            text: lib.migrate.spinners.migrationComplete,
         });
     }
     return pollResponse.buildId;
 }
-async function downloadProjectFiles(derivedAccountId, projectName, buildId, projectDest, projectConfig) {
+export async function downloadProjectFiles(derivedAccountId, projectName, buildId, projectDest, projectConfig) {
     try {
-        SpinniesManager_1.default.add('fetchingMigratedProject', {
-            text: en_1.lib.migrate.spinners.downloadingProjectContents,
+        SpinniesManager.add('fetchingMigratedProject', {
+            text: lib.migrate.spinners.downloadingProjectContents,
         });
-        const { data: zippedProject } = await (0, projects_2.downloadProject)(derivedAccountId, projectName, buildId);
+        const { data: zippedProject } = await downloadProject(derivedAccountId, projectName, buildId);
         let absoluteDestPath;
         if (projectConfig?.projectConfig && projectConfig?.projectDir) {
             const { projectDir } = projectConfig;
             absoluteDestPath = projectDir;
             const { srcDir } = projectConfig.projectConfig;
-            const archiveDest = path_1.default.join(projectDir, 'archive');
+            const archiveDest = path.join(projectDir, 'archive');
             // Move the existing source directory to archive
-            fs_1.default.renameSync(path_1.default.join(projectDir, srcDir), archiveDest);
-            logger_1.uiLogger.info(en_1.lib.migrate.sourceContentsMoved(archiveDest));
+            fs.renameSync(path.join(projectDir, srcDir), archiveDest);
+            uiLogger.info(lib.migrate.sourceContentsMoved(archiveDest));
         }
         else {
             absoluteDestPath = projectDest
-                ? path_1.default.resolve((0, path_2.getCwd)(), projectDest)
-                : (0, path_2.getCwd)();
+                ? path.resolve(getCwd(), projectDest)
+                : getCwd();
         }
-        await (0, archive_1.extractZipArchive)(zippedProject, (0, path_2.sanitizeFileName)(projectName), absoluteDestPath, {
+        await extractZipArchive(zippedProject, sanitizeFileName(projectName), absoluteDestPath, {
             includesRootDir: true,
             hideLogs: true,
         });
-        SpinniesManager_1.default.succeed('fetchingMigratedProject', {
-            text: en_1.lib.migrate.spinners.downloadingProjectContentsComplete,
+        SpinniesManager.succeed('fetchingMigratedProject', {
+            text: lib.migrate.spinners.downloadingProjectContentsComplete,
         });
-        logger_1.uiLogger.success(`Saved ${projectName} to ${projectDest}`);
+        uiLogger.success(lib.migrate.success.downloadedProject(projectName, projectDest));
     }
     catch (error) {
-        SpinniesManager_1.default.fail('fetchingMigratedProject', {
-            text: en_1.lib.migrate.spinners.downloadingProjectContentsFailed,
+        SpinniesManager.fail('fetchingMigratedProject', {
+            text: lib.migrate.spinners.downloadingProjectContentsFailed,
         });
         throw error;
     }
 }
-async function migrateApp2025_2(derivedAccountId, options, projectConfig) {
-    SpinniesManager_1.default.init();
-    const ungatedForUnifiedApps = await (0, hasFeature_1.hasFeature)(derivedAccountId, constants_1.FEATURES.UNIFIED_APPS);
+export async function migrateApp2025_2(derivedAccountId, options, projectConfig) {
+    SpinniesManager.init();
+    const ungatedForUnifiedApps = await hasUnfiedAppsAccess(derivedAccountId);
     if (!ungatedForUnifiedApps) {
-        throw new Error(en_1.lib.migrate.errors.notUngatedForUnifiedApps((0, ui_1.uiAccountDescription)(derivedAccountId)));
+        throw new Error(lib.migrate.errors.notUngatedForUnifiedApps(uiAccountDescription(derivedAccountId)));
     }
     if (projectConfig) {
         if (!projectConfig?.projectConfig || !projectConfig?.projectDir) {
-            throw new Error(en_1.lib.migrate.errors.project.invalidConfig);
+            throw new Error(lib.migrate.errors.project.invalidConfig);
         }
-        const { projectExists } = await (0, ensureProjectExists_1.ensureProjectExists)(derivedAccountId, projectConfig.projectConfig.name, { allowCreate: false, noLogs: true });
+        const { projectExists } = await ensureProjectExists(derivedAccountId, projectConfig.projectConfig.name, { allowCreate: false, noLogs: true });
         if (!projectExists) {
-            throw new Error(en_1.lib.migrate.errors.project.doesNotExist(derivedAccountId));
+            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);
-    logger_1.uiLogger.log((0, ui_1.uiLink)('Project Details', (0, urls_1.getProjectDetailUrl)(projectName, derivedAccountId)));
-    logger_1.uiLogger.log((0, ui_1.uiLink)('Build Details', (0, urls_1.getProjectBuildDetailUrl)(projectName, buildId, derivedAccountId)));
+    uiLogger.log(uiLink('Project Details', getProjectDetailUrl(projectName, derivedAccountId)));
+    uiLogger.log(uiLink('Build Details', getProjectBuildDetailUrl(projectName, buildId, derivedAccountId)));
 }
-function logInvalidAccountError() {
-    (0, ui_1.uiLine)();
-    logger_1.uiLogger.error(en_1.lib.migrate.errors.invalidAccountTypeTitle);
-    logger_1.uiLogger.log(en_1.lib.migrate.errors.invalidAccountTypeDescription((0, ui_1.uiCommandReference)('hs account use'), (0, ui_1.uiCommandReference)('hs auth')));
-    (0, ui_1.uiLine)();
+export function logInvalidAccountError() {
+    uiLine();
+    uiLogger.error(lib.migrate.errors.invalidAccountTypeTitle);
+    uiLogger.log(lib.migrate.errors.invalidAccountTypeDescription(uiCommandReference('hs account use'), uiCommandReference('hs auth')));
+    uiLine();
 }

package/lib/app/migrate_legacy.d.ts

@@ -1,4 +1,4 @@
 import { CLIAccount } from '@hubspot/local-dev-lib/types/Accounts';
 import { ArgumentsCamelCase } from 'yargs';
-import { MigrateAppArgs } from './migrate';
+import { MigrateAppArgs } from './migrate.js';
 export declare function migrateApp2023_2(derivedAccountId: number, options: ArgumentsCamelCase<MigrateAppArgs>, accountConfig: CLIAccount): Promise<void>;