@hubspot/cli 8.1.0 → 8.1.2-experimental.0

package/lib/prompts/selectPublicAppForMigrationPrompt.js

@@ -4,13 +4,14 @@ import { uiLine } from '../ui/index.js';
 import { logError } from '../errorHandlers/index.js';
 import { uiLogger } from '../ui/logger.js';
 import { fetchPublicAppsForPortal } from '@hubspot/local-dev-lib/api/appsDev';
+import { isPromptExitError, PromptExitError, } from '../errors/PromptExitError.js';
 import { EXIT_CODES } from '../enums/exitCodes.js';
 async function fetchPublicAppOptions(accountId, accountName, isMigratingApp = false) {
+    if (!accountId) {
+        uiLogger.error(lib.prompts.selectPublicAppForMigrationPrompt.errors.noAccountId);
+        throw new PromptExitError(lib.prompts.selectPublicAppForMigrationPrompt.errors.noAccountId, EXIT_CODES.ERROR);
+    }
     try {
-        if (!accountId) {
-            uiLogger.error(lib.prompts.selectPublicAppForMigrationPrompt.errors.noAccountId);
-            process.exit(EXIT_CODES.ERROR);
-        }
         const { data: { results: publicApps }, } = await fetchPublicAppsForPortal(accountId);
         const filteredPublicApps = publicApps.filter(app => !app.projectId && !app.sourceId);
         if (!filteredPublicApps.length ||
@@ -24,14 +25,19 @@ async function fetchPublicAppOptions(accountId, accountName, isMigratingApp = fa
                 uiLogger.error(`${lib.prompts.selectPublicAppForMigrationPrompt.errors.noAppsClone}\n${lib.prompts.selectPublicAppForMigrationPrompt.errors.noAppsCloneMessage(accountName)}`);
             }
             uiLine();
-            process.exit(EXIT_CODES.SUCCESS);
+            throw new PromptExitError(isMigratingApp
+                ? lib.prompts.selectPublicAppForMigrationPrompt.errors.noAppsMigration
+                : lib.prompts.selectPublicAppForMigrationPrompt.errors.noAppsClone, EXIT_CODES.SUCCESS);
         }
         return filteredPublicApps;
     }
     catch (error) {
+        if (isPromptExitError(error)) {
+            throw error;
+        }
         logError(error, accountId ? { accountId } : undefined);
         uiLogger.error(lib.prompts.selectPublicAppForMigrationPrompt.errors.errorFetchingApps);
-        process.exit(EXIT_CODES.ERROR);
+        throw new PromptExitError(lib.prompts.selectPublicAppForMigrationPrompt.errors.errorFetchingApps, EXIT_CODES.ERROR);
     }
 }
 export async function selectPublicAppForMigrationPrompt({ accountId, accountName, isMigratingApp = false, }) {

package/lib/sandboxes.d.ts

@@ -1,22 +1,14 @@
 import { AccountType, HubSpotConfigAccount } from '@hubspot/local-dev-lib/types/Accounts';
 import { Environment } from '@hubspot/local-dev-lib/types/Accounts';
-import { SandboxSyncTask, SandboxAccountType } from '../types/Sandboxes.js';
-export declare const SYNC_TYPES: {
-    readonly OBJECT_RECORDS: "object-records";
-};
+import { SandboxAccountType } from '../types/Sandboxes.js';
 export declare const SANDBOX_TYPE_MAP: {
     [key: string]: SandboxAccountType;
 };
-export declare const SANDBOX_API_TYPE_MAP: {
-    readonly STANDARD_SANDBOX: 1;
-    readonly DEVELOPMENT_SANDBOX: 2;
-};
 export declare const SANDBOX_TYPE_MAP_V2: {
     readonly STANDARD_SANDBOX: "STANDARD";
     readonly DEVELOPMENT_SANDBOX: "DEVELOPER";
 };
 export declare function getSandboxTypeAsString(accountType?: AccountType): string;
 export declare function getHasSandboxesByType(parentAccountConfig: HubSpotConfigAccount, type: AccountType): boolean;
-export declare function getAvailableSyncTypes(parentAccountConfig: HubSpotConfigAccount, config: HubSpotConfigAccount): Promise<Array<SandboxSyncTask>>;
 export declare function validateSandboxUsageLimits(accountConfig: HubSpotConfigAccount, sandboxType: AccountType, env: Environment): Promise<void>;
 export declare function handleSandboxCreateError(err: unknown, env: Environment, name: string, accountId: number): never;

package/lib/sandboxes.js

@@ -1,5 +1,4 @@
 import { getSandboxUsageLimits } from '@hubspot/local-dev-lib/api/sandboxHubs';
-import { fetchTypes } from '@hubspot/local-dev-lib/api/sandboxSync';
 import { getAllConfigAccounts } from '@hubspot/local-dev-lib/config';
 import { getHubSpotWebsiteOrigin } from '@hubspot/local-dev-lib/urls';
 import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
@@ -8,19 +7,12 @@ 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',
-};
 export const SANDBOX_TYPE_MAP = {
     dev: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
     developer: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
     development: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
     standard: HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX,
 };
-export const SANDBOX_API_TYPE_MAP = {
-    [HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX]: 1,
-    [HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX]: 2,
-};
 export const SANDBOX_TYPE_MAP_V2 = {
     [HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX]: 'STANDARD',
     [HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX]: 'DEVELOPER',
@@ -45,19 +37,6 @@ export function getHasSandboxesByType(parentAccountConfig, type) {
     }
     return false;
 }
-// Fetches available sync types for a given sandbox portal
-export async function getAvailableSyncTypes(parentAccountConfig, config) {
-    const parentPortalId = parentAccountConfig.accountId;
-    const portalId = config.accountId;
-    if (!parentPortalId || !portalId) {
-        throw new Error(lib.sandbox.sync.failure.syncTypeFetch);
-    }
-    const { data: { results: syncTypes }, } = await fetchTypes(parentPortalId, portalId);
-    if (!syncTypes) {
-        throw new Error(lib.sandbox.sync.failure.syncTypeFetch);
-    }
-    return syncTypes.map(t => ({ type: t.name }));
-}
 export async function validateSandboxUsageLimits(accountConfig, sandboxType, env) {
     const accountId = accountConfig.accountId;
     if (!accountId) {

package/lib/serverlessLogs.js

@@ -9,7 +9,6 @@ import { outputLogs } from './ui/serverlessFunctionLogs.js';
 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 { lib } from '../lang/en.js';
 const TAIL_DELAY = 5000;
 function base64EncodeString(valueToEncode) {
@@ -19,19 +18,6 @@ function base64EncodeString(valueToEncode) {
     const stringBuffer = Buffer.from(valueToEncode);
     return encodeURIComponent(stringBuffer.toString('base64'));
 }
-function handleUserInput() {
-    const onTerminate = async () => {
-        SpinniesManager.remove('tailLogs');
-        SpinniesManager.remove('stopMessage');
-        process.exit(EXIT_CODES.SUCCESS);
-    };
-    handleExit(onTerminate);
-    handleKeypress(key => {
-        if ((key.ctrl && key.name == 'c') || key.name === 'q') {
-            onTerminate();
-        }
-    });
-}
 async function verifyAccessKeyAndUserAccess(accountId, scopeGroup) {
     const accountConfig = getConfigAccountById(accountId);
     if (!accountConfig) {
@@ -80,40 +66,60 @@ export async function tailLogs(accountId, name, fetchLatest, tailCall, compact =
             }
         }
     }
-    async function tail(after) {
-        let latestLog;
-        let nextAfter;
-        try {
-            const { data } = await tailCall(after);
-            latestLog = data;
-            nextAfter = latestLog.paging.next.after;
+    return new Promise(resolve => {
+        function cleanup() {
+            SpinniesManager.remove('tailLogs');
+            SpinniesManager.remove('stopMessage');
         }
-        catch (e) {
-            if (isHubSpotHttpError(e) && e.status !== 404) {
-                logError(e, new ApiErrorContext({
-                    accountId,
-                }));
+        let resolved = false;
+        const onTerminate = async () => {
+            if (resolved)
+                return;
+            resolved = true;
+            cleanup();
+            resolve();
+        };
+        handleExit(onTerminate);
+        handleKeypress(key => {
+            if ((key.ctrl && key.name == 'c') || key.name === 'q') {
+                onTerminate();
             }
-            process.exit(EXIT_CODES.SUCCESS);
-        }
-        if (latestLog && latestLog.results.length) {
-            outputLogs(latestLog, {
-                compact,
-            });
+        });
+        async function tail(after) {
+            let latestLog;
+            let nextAfter;
+            try {
+                const { data } = await tailCall(after);
+                latestLog = data;
+                nextAfter = latestLog.paging.next.after;
+            }
+            catch (e) {
+                if (isHubSpotHttpError(e) && e.status !== 404) {
+                    logError(e, new ApiErrorContext({
+                        accountId,
+                    }));
+                }
+                await onTerminate();
+                return;
+            }
+            if (latestLog && latestLog.results.length) {
+                outputLogs(latestLog, {
+                    compact,
+                });
+            }
+            setTimeout(async () => {
+                await tail(nextAfter);
+            }, TAIL_DELAY);
         }
-        setTimeout(async () => {
-            await tail(nextAfter);
-        }, TAIL_DELAY);
-    }
-    SpinniesManager.add('tailLogs', {
-        text: `Following logs for ${name}`,
-    });
-    SpinniesManager.add('stopMessage', {
-        text: `> Press ${chalk.bold('q')} to stop following`,
-        status: 'non-spinnable',
+        SpinniesManager.add('tailLogs', {
+            text: `Following logs for ${name}`,
+        });
+        SpinniesManager.add('stopMessage', {
+            text: `> Press ${chalk.bold('q')} to stop following`,
+            status: 'non-spinnable',
+        });
+        tail(initialAfter);
     });
-    handleUserInput();
-    await tail(initialAfter);
 }
 export async function outputBuildLog(buildLogUrl) {
     if (!buildLogUrl) {

package/lib/theme/cmsDevServerProcess.d.ts

@@ -0,0 +1,14 @@
+import { ChildProcess } from 'child_process';
+import { ExitFunction } from '../../types/Yargs.js';
+interface DevServerOptions {
+    absoluteSrc: string;
+    accountName?: string;
+    noSsl?: boolean;
+    port?: number;
+    generateFieldsTypes?: boolean;
+    resetSession?: boolean;
+    dest: string;
+    exit: ExitFunction;
+}
+export declare function spawnDevServer(options: DevServerOptions): Promise<ChildProcess>;
+export {};

package/lib/theme/cmsDevServerProcess.js

@@ -0,0 +1,149 @@
+import { spawn } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+import { fileURLToPath } from 'url';
+import { getConfigFilePath } from '@hubspot/local-dev-lib/config';
+import SpinniesManager from '../ui/SpinniesManager.js';
+import { lib } from '../../lang/en.js';
+import { EXIT_CODES } from '../enums/exitCodes.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// cms-dev-server version to install to isolated cache
+const TARGET_CMS_DEV_SERVER_VERSION = '1.2.26';
+/**
+ * Ensures cms-dev-server is installed in an isolated cache directory.
+ * This prevents React version conflicts with the CLI.
+ */
+async function ensureCmsDevServerCache(targetVersion) {
+    const cacheDir = path.join(os.homedir(), '.hscli', '.module-cache');
+    const packageJsonPath = path.join(cacheDir, 'node_modules', '@hubspot', 'cms-dev-server', 'package.json');
+    // Check if already installed with correct version
+    let needsInstall = true;
+    if (fs.existsSync(packageJsonPath)) {
+        try {
+            const installedPackage = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+            if (installedPackage.version === targetVersion) {
+                needsInstall = false;
+            }
+        }
+        catch (e) {
+            // If we can't read the package.json, reinstall
+            needsInstall = true;
+        }
+    }
+    if (needsInstall) {
+        // Show spinner during install (can take 10-30 seconds)
+        SpinniesManager.init({
+            succeedColor: 'white',
+        });
+        SpinniesManager.add('cms-dev-server-install', {
+            text: lib.theme.cmsDevServerProcess.installStarted(targetVersion),
+        });
+        // Create cache directory
+        fs.mkdirSync(cacheDir, { recursive: true });
+        // Clear old installation if exists
+        const nodeModulesDir = path.join(cacheDir, 'node_modules');
+        if (fs.existsSync(nodeModulesDir)) {
+            fs.rmSync(nodeModulesDir, { recursive: true, force: true });
+        }
+        // Install cms-dev-server with production dependencies only (async to allow spinner)
+        await new Promise((resolve, reject) => {
+            const installProcess = spawn('npm', [
+                'install',
+                `@hubspot/cms-dev-server@${targetVersion}`,
+                '--production',
+                '--no-save',
+                '--loglevel=error',
+            ], {
+                cwd: cacheDir,
+                stdio: 'ignore', // Suppress npm output
+            });
+            installProcess.on('close', code => {
+                if (code === 0) {
+                    SpinniesManager.succeed('cms-dev-server-install', {
+                        text: lib.theme.cmsDevServerProcess.installSucceeded,
+                    });
+                    resolve();
+                }
+                else {
+                    SpinniesManager.fail('cms-dev-server-install', {
+                        text: lib.theme.cmsDevServerProcess.installFailed,
+                    });
+                    reject(new Error(lib.theme.cmsDevServerProcess.installFailed));
+                }
+            });
+            installProcess.on('error', error => {
+                SpinniesManager.fail('cms-dev-server-install', {
+                    text: lib.theme.cmsDevServerProcess.installFailed,
+                });
+                reject(error);
+            });
+        });
+    }
+    return cacheDir;
+}
+export async function spawnDevServer(options) {
+    const { absoluteSrc, accountName, noSsl, port, generateFieldsTypes, resetSession, dest, exit, } = options;
+    // Ensure cms-dev-server is installed in isolated cache
+    const cacheDir = await ensureCmsDevServerCache(TARGET_CMS_DEV_SERVER_VERSION);
+    // Get config path to pass to createDevServer
+    let configPath = '';
+    try {
+        configPath = process.env.HUBSPOT_CONFIG_PATH || getConfigFilePath();
+    }
+    catch (e) {
+        // Config file doesn't exist - cms-dev-server will handle this gracefully
+    }
+    // Copy the runner script to the cache directory so imports resolve from there
+    // This is critical: Node resolves ES module imports relative to the script location,
+    // not the cwd. By copying the script to the cache directory, imports will resolve
+    // from the cache's node_modules (React 18) instead of the CLI's node_modules (React 19)
+    const sourceRunnerPath = path.join(__dirname, 'cmsDevServerRunner.js');
+    const targetRunnerPath = path.join(cacheDir, 'cmsPreviewRunner.js');
+    fs.copyFileSync(sourceRunnerPath, targetRunnerPath);
+    // Set environment variables to pass configuration to the runner script
+    const env = { ...process.env };
+    env.CMS_DEV_SERVER_SRC = absoluteSrc;
+    env.CMS_DEV_SERVER_DEST = dest;
+    env.CMS_DEV_SERVER_CONFIG = configPath;
+    env.CMS_DEV_SERVER_ACCOUNT = accountName || '';
+    env.CMS_DEV_SERVER_SSL = (!noSsl).toString();
+    env.CMS_DEV_SERVER_FIELD_GEN = Boolean(generateFieldsTypes).toString();
+    env.CMS_DEV_SERVER_RESET_SESSION = Boolean(resetSession).toString();
+    if (port) {
+        env.PORT = port.toString();
+    }
+    // Suppress Node.js deprecation warnings
+    env.NODE_NO_WARNINGS = '1';
+    // Spawn Node with the runner script from the isolated cache directory
+    // This ensures complete isolation from CLI's React 19
+    const devServer = spawn('node', [targetRunnerPath], {
+        stdio: 'inherit',
+        env,
+        cwd: cacheDir,
+    });
+    // Handle process events
+    devServer.on('error', async (error) => {
+        console.error(lib.theme.cmsDevServerProcess.serverStartError(error));
+        await exit(EXIT_CODES.ERROR);
+    });
+    devServer.on('exit', async (code, signal) => {
+        if (code !== 0 && code !== null) {
+            console.error(lib.theme.cmsDevServerProcess.serverExit(code));
+            await exit(code);
+        }
+        if (signal) {
+            console.error(lib.theme.cmsDevServerProcess.serverKill(signal));
+            await exit(EXIT_CODES.ERROR);
+        }
+    });
+    // Handle CLI termination
+    process.once('SIGINT', () => {
+        devServer.kill('SIGINT');
+    });
+    process.once('SIGTERM', () => {
+        devServer.kill('SIGTERM');
+    });
+    return devServer;
+}

package/lib/theme/cmsDevServerRunner.d.ts

@@ -0,0 +1,14 @@
+/**
+ * This script runs in an isolated cache directory with cms-dev-server installed.
+ * It is spawned as a separate process to avoid React version conflicts with the CLI.
+ *
+ * Arguments are passed via environment variables:
+ * - CMS_DEV_SERVER_SRC: Source directory path
+ * - CMS_DEV_SERVER_DEST: Destination path
+ * - CMS_DEV_SERVER_CONFIG: Config file path (optional)
+ * - CMS_DEV_SERVER_ACCOUNT: Account name (optional)
+ * - CMS_DEV_SERVER_SSL: 'true' or 'false'
+ * - CMS_DEV_SERVER_FIELD_GEN: 'true' or 'false'
+ * - CMS_DEV_SERVER_RESET_SESSION: 'true' or 'false'
+ */
+export {};

package/lib/theme/cmsDevServerRunner.js

@@ -0,0 +1,90 @@
+// @ts-nocheck
+/**
+ * This script runs in an isolated cache directory with cms-dev-server installed.
+ * It is spawned as a separate process to avoid React version conflicts with the CLI.
+ *
+ * Arguments are passed via environment variables:
+ * - CMS_DEV_SERVER_SRC: Source directory path
+ * - CMS_DEV_SERVER_DEST: Destination path
+ * - CMS_DEV_SERVER_CONFIG: Config file path (optional)
+ * - CMS_DEV_SERVER_ACCOUNT: Account name (optional)
+ * - CMS_DEV_SERVER_SSL: 'true' or 'false'
+ * - CMS_DEV_SERVER_FIELD_GEN: 'true' or 'false'
+ * - CMS_DEV_SERVER_RESET_SESSION: 'true' or 'false'
+ */
+// Suppress library deprecation warnings (e.g., body-parser)
+process.noDeprecation = true;
+// Dynamic imports to use the isolated cms-dev-server installation
+const { createDevServer } = await import('@hubspot/cms-dev-server');
+const { walk } = await import('@hubspot/local-dev-lib/fs');
+const { createIgnoreFilter } = await import('@hubspot/local-dev-lib/ignoreRules');
+const { isAllowedExtension } = await import('@hubspot/local-dev-lib/path');
+const { FILE_UPLOAD_RESULT_TYPES } = await import('@hubspot/local-dev-lib/constants/files');
+const cliProgress = (await import('cli-progress')).default;
+// Read configuration from environment variables
+const src = process.env.CMS_DEV_SERVER_SRC;
+const dest = process.env.CMS_DEV_SERVER_DEST;
+const configPath = process.env.CMS_DEV_SERVER_CONFIG || '';
+const accountName = process.env.CMS_DEV_SERVER_ACCOUNT || '';
+const sslEnabled = process.env.CMS_DEV_SERVER_SSL === 'true';
+const fieldGenEnabled = process.env.CMS_DEV_SERVER_FIELD_GEN === 'true';
+const resetSession = process.env.CMS_DEV_SERVER_RESET_SESSION === 'true';
+// Get uploadable files for preview
+let filePaths = [];
+try {
+    filePaths = await walk(src);
+}
+catch (e) {
+    console.error('Error walking directory:', e);
+}
+filePaths = filePaths
+    .filter(file => isAllowedExtension(file))
+    .filter(createIgnoreFilter(false));
+// Create progress bar for initial upload
+function startProgressBar(numFiles) {
+    const initialUploadProgressBar = new cliProgress.SingleBar({
+        gracefulExit: true,
+        format: '[{bar}] {percentage}% | {value}/{total} | {label}',
+        hideCursor: true,
+    }, cliProgress.Presets.rect);
+    initialUploadProgressBar.start(numFiles, 0, {
+        label: 'Preparing upload...',
+    });
+    let uploadsHaveStarted = false;
+    return {
+        onAttemptCallback: () => { },
+        onSuccessCallback: () => {
+            initialUploadProgressBar.increment();
+            if (!uploadsHaveStarted) {
+                uploadsHaveStarted = true;
+                initialUploadProgressBar.update(0, {
+                    label: 'Uploading files...',
+                });
+            }
+        },
+        onFirstErrorCallback: () => { },
+        onRetryCallback: () => { },
+        onFinalErrorCallback: () => initialUploadProgressBar.increment(),
+        // eslint-disable-next-line
+        onFinishCallback: (results) => {
+            initialUploadProgressBar.update(numFiles, {
+                label: 'Upload complete',
+            });
+            initialUploadProgressBar.stop();
+            results.forEach(result => {
+                if (result.resultType === FILE_UPLOAD_RESULT_TYPES.FAILURE) {
+                    console.error(`Failed to upload ${result.file}`);
+                }
+            });
+        },
+    };
+}
+const themePreviewOptions = {
+    filePaths,
+    startProgressBar,
+    resetSession,
+    dest,
+};
+createDevServer(src, false, // storybook
+configPath, accountName, sslEnabled, fieldGenEnabled, themePreviewOptions);
+export {};

package/lib/theme/migrate.d.ts

@@ -10,4 +10,4 @@ export declare function getHasMigratableThemes(projectConfig?: LoadedProjectConf
 }>;
 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>;
+export declare function migrateThemesV2(derivedAccountId: number, options: ArgumentsCamelCase<MigrateThemesArgs>, themeCount: number, projectConfig: LoadedProjectConfig): Promise<void>;

package/lib/theme/migrate.js

@@ -7,7 +7,6 @@ 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) {
@@ -22,9 +21,6 @@ export async function getHasMigratableThemes(projectConfig) {
     };
 }
 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);
     }
@@ -61,7 +57,7 @@ export async function handleThemesMigration(projectConfig, platformVersion) {
     uiLogger.log('');
     uiLogger.log(lib.migrate.success.themesMigrationSuccess(platformVersion));
 }
-export async function migrateThemes2025_2(derivedAccountId, options, themeCount, projectConfig) {
+export async function migrateThemesV2(derivedAccountId, options, themeCount, projectConfig) {
     if (!projectConfig?.projectConfig || !projectConfig?.projectDir) {
         throw new Error(lib.migrate.errors.project.invalidConfig);
     }

package/lib/ui/SpinniesManager.d.ts

@@ -12,6 +12,7 @@ declare class SpinniesManager {
     private lineCount;
     private currentFrameIndex;
     private spin;
+    private sigintHandler;
     constructor();
     init(options?: Partial<SpinnerState>): void;
     private resetState;

package/lib/ui/SpinniesManager.js

@@ -10,7 +10,8 @@ The above copyright notice and this permission notice shall be included in all c
 import readline from 'readline';
 import chalk from 'chalk';
 import cliCursor from 'cli-cursor';
-import { breakText, cleanStream, colorOptions, getLinesLength, prefixOptions, purgeSpinnerOptions, purgeSpinnersOptions, SPINNERS, terminalSupportsUnicode, writeStream, } from './spinniesUtils.js';
+import { breakText, cleanStream, colorOptions, getLinesLength, prefixOptions, purgeSpinnerOptions, purgeSpinnersOptions, SPINNERS, writeStream, } from './spinniesUtils.js';
+import { isUnicodeSupported } from '@hubspot/local-dev-lib/isUnicodeSupported';
 import { uiLogger } from './logger.js';
 function safeColor(text, color) {
     const chalkFn = chalk[color];
@@ -29,6 +30,7 @@ class SpinniesManager {
     lineCount = 0;
     currentFrameIndex = 0;
     spin;
+    sigintHandler = null;
     constructor() {
         this.resetState();
     }
@@ -37,7 +39,7 @@ class SpinniesManager {
             spinnerColor: 'greenBright',
             succeedColor: 'green',
             failColor: 'red',
-            spinner: terminalSupportsUnicode() ? SPINNERS.dots : SPINNERS.dashes,
+            spinner: isUnicodeSupported() ? SPINNERS.dots : SPINNERS.dashes,
             disableSpins: false,
             ...purgeSpinnersOptions(options),
         };
@@ -103,6 +105,8 @@ class SpinniesManager {
             return;
         }
         delete this.spinners[name];
+        // Update the spinner state to clean up the deleted spinner
+        this.updateSpinnerState();
     }
     stopAll(newStatus = 'stopped') {
         Object.keys(this.spinners).forEach(name => {
@@ -245,12 +249,24 @@ class SpinniesManager {
         }
     }
     bindSigint() {
-        process.removeAllListeners('SIGINT');
-        process.on('SIGINT', () => {
+        if (this.sigintHandler) {
+            process.removeListener('SIGINT', this.sigintHandler);
+        }
+        this.sigintHandler = () => {
             cliCursor.show();
             readline.moveCursor(process.stderr, 0, this.lineCount);
-            process.exit(0);
-        });
+            const remainingListeners = process
+                .listeners('SIGINT')
+                .filter(l => l !== this.sigintHandler);
+            if (remainingListeners.length === 0) {
+                // process.exit is intentionally used here rather than the command-level
+                // exit() function because this SIGINT handler runs outside of a command
+                // context and needs to force-terminate the process when no other SIGINT
+                // listeners remain to handle it.
+                process.exit(0);
+            }
+        };
+        process.on('SIGINT', this.sigintHandler);
     }
 }
 const toExport = new SpinniesManager();

package/lib/ui/accountTable.d.ts

@@ -0,0 +1,8 @@
+import { HubSpotConfigAccount } from '@hubspot/local-dev-lib/types/Accounts';
+export declare function sortAndMapAccounts(accounts: HubSpotConfigAccount[]): {
+    [key: string]: HubSpotConfigAccount[];
+};
+export declare function getAccountData(mappedAccountData: {
+    [key: string]: HubSpotConfigAccount[];
+}): string[][];
+export declare function renderAccountTable(showAllLabel?: boolean): void;