@hubspot/cli 7.7.0-experimental.3 → 7.7.0

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 { useV3Api } 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('@hubspot/local-dev-lib/logger');
+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 mockedUseV3Api = useV3Api;
+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(() => {
+        mockedUseV3Api.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 (v3 API)', async () => {
+            mockedUseV3Api.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 { useV3Api } 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 (useV3Api(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

@@ -1,4 +1,4 @@
-import { SpinnerOptions as BaseSpinnerOptions, VALID_STATUSES } from './spinniesUtils';
+import { SpinnerOptions as BaseSpinnerOptions, VALID_STATUSES } from './spinniesUtils.js';
 interface SpinnerState extends BaseSpinnerOptions {
     name?: string;
 }

package/lib/ui/SpinniesManager.js

@@ -1,4 +1,3 @@
-"use strict";
 /*
 https://github.com/jbcarpanelli/spinnies
 
@@ -8,16 +7,12 @@ Permission is hereby granted, free of charge, to any person obtaining a copy of
 
 The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 **/
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const readline_1 = __importDefault(require("readline"));
-const chalk_1 = __importDefault(require("chalk"));
-const cli_cursor_1 = __importDefault(require("cli-cursor"));
-const spinniesUtils_1 = require("./spinniesUtils");
+import readline from 'readline';
+import chalk from 'chalk';
+import cliCursor from 'cli-cursor';
+import { breakText, cleanStream, colorOptions, getLinesLength, purgeSpinnerOptions, purgeSpinnersOptions, SPINNERS, terminalSupportsUnicode, writeStream, prefixOptions, } from './spinniesUtils.js';
 function safeColor(text, color) {
-    const chalkFn = chalk_1.default[color];
+    const chalkFn = chalk[color];
     if (typeof chalkFn === 'function') {
         return chalkFn(text);
     }
@@ -40,9 +35,9 @@ class SpinniesManager {
             spinnerColor: 'greenBright',
             succeedColor: 'green',
             failColor: 'red',
-            spinner: (0, spinniesUtils_1.terminalSupportsUnicode)() ? spinniesUtils_1.SPINNERS.dots : spinniesUtils_1.SPINNERS.dashes,
+            spinner: terminalSupportsUnicode() ? SPINNERS.dots : SPINNERS.dashes,
             disableSpins: false,
-            ...(0, spinniesUtils_1.purgeSpinnersOptions)(options),
+            ...purgeSpinnersOptions(options),
         };
         this.spin =
             !this.options.disableSpins &&
@@ -76,11 +71,11 @@ class SpinniesManager {
             options.text = resolvedName;
         }
         const spinnerProperties = {
-            ...(0, spinniesUtils_1.colorOptions)(this.options),
+            ...colorOptions(this.options),
             succeedPrefix: this.options.succeedPrefix,
             failPrefix: this.options.failPrefix,
             status: 'spinning',
-            ...(0, spinniesUtils_1.purgeSpinnerOptions)(options),
+            ...purgeSpinnerOptions(options),
         };
         this.spinners[resolvedName] = spinnerProperties;
         this.updateSpinnerState();
@@ -142,7 +137,7 @@ class SpinniesManager {
         if (!this.spinners[name]) {
             throw Error(`No spinner initialized with name ${name}`);
         }
-        options = (0, spinniesUtils_1.purgeSpinnerOptions)(options);
+        options = purgeSpinnerOptions(options);
         status = status || 'spinning';
         this.spinners[name] = { ...this.spinners[name], ...options, status };
     }
@@ -153,7 +148,7 @@ class SpinniesManager {
             }
             this.currentInterval = this.loopStream();
             if (!this.isCursorHidden) {
-                cli_cursor_1.default.hide();
+                cliCursor.hide();
             }
             this.isCursorHidden = true;
             this.checkIfActiveSpinners();
@@ -163,8 +158,8 @@ class SpinniesManager {
         }
     }
     loopStream() {
-        const frames = this.options.spinner?.frames || spinniesUtils_1.SPINNERS.dots.frames;
-        const interval = this.options.spinner?.interval || spinniesUtils_1.SPINNERS.dots.interval;
+        const frames = this.options.spinner?.frames || SPINNERS.dots.frames;
+        const interval = this.options.spinner?.interval || SPINNERS.dots.interval;
         return setInterval(() => {
             this.setStreamOutput(frames[this.currentFrameIndex]);
             this.currentFrameIndex =
@@ -179,13 +174,13 @@ class SpinniesManager {
         const hasActiveSpinners = this.hasActiveSpinners();
         Object.values(this.spinners).forEach(spinner => {
             let { text } = spinner;
-            const { status, color, spinnerColor, succeedColor, failColor, indent = 0, succeedPrefix = (0, spinniesUtils_1.prefixOptions)(this.options).succeedPrefix, failPrefix = (0, spinniesUtils_1.prefixOptions)(this.options).failPrefix, } = spinner;
+            const { status, color, spinnerColor, succeedColor, failColor, indent = 0, succeedPrefix = prefixOptions(this.options).succeedPrefix, failPrefix = prefixOptions(this.options).failPrefix, } = spinner;
             let line;
             let prefixLength = indent;
             text = text ?? '';
             if (status === 'spinning') {
                 prefixLength += frame.length + 1;
-                text = (0, spinniesUtils_1.breakText)(text, prefixLength);
+                text = breakText(text, prefixLength);
                 const colorizedFrame = safeColor(frame, spinnerColor);
                 const colorizedText = safeColor(text, color);
                 line = `${colorizedFrame} ${colorizedText}`;
@@ -194,35 +189,35 @@ class SpinniesManager {
                 if (status === 'succeed') {
                     prefixLength += succeedPrefix.length + 1;
                     if (hasActiveSpinners) {
-                        text = (0, spinniesUtils_1.breakText)(text, prefixLength);
+                        text = breakText(text, prefixLength);
                     }
                     const colorizedText = safeColor(text, succeedColor);
-                    line = `${chalk_1.default.green(succeedPrefix)} ${colorizedText}`;
+                    line = `${chalk.green(succeedPrefix)} ${colorizedText}`;
                 }
                 else if (status === 'fail') {
                     prefixLength += failPrefix.length + 1;
                     if (hasActiveSpinners) {
-                        text = (0, spinniesUtils_1.breakText)(text, prefixLength);
+                        text = breakText(text, prefixLength);
                     }
                     const colorizedText = safeColor(text, failColor);
-                    line = `${chalk_1.default.red(failPrefix)} ${colorizedText}`;
+                    line = `${chalk.red(failPrefix)} ${colorizedText}`;
                 }
                 else {
                     if (hasActiveSpinners) {
-                        text = (0, spinniesUtils_1.breakText)(text, prefixLength);
+                        text = breakText(text, prefixLength);
                     }
                     line = safeColor(text, color);
                 }
             }
-            linesLength.push(...(0, spinniesUtils_1.getLinesLength)(text, prefixLength));
+            linesLength.push(...getLinesLength(text, prefixLength));
             output += indent ? `${' '.repeat(indent)}${line}\n` : `${line}\n`;
         });
         if (!hasActiveSpinners) {
-            readline_1.default.clearScreenDown(this.stream);
+            readline.clearScreenDown(this.stream);
         }
-        (0, spinniesUtils_1.writeStream)(this.stream, output, linesLength);
+        writeStream(this.stream, output, linesLength);
         if (hasActiveSpinners) {
-            (0, spinniesUtils_1.cleanStream)(this.stream, linesLength);
+            cleanStream(this.stream, linesLength);
         }
         this.lineCount = linesLength.length;
     }
@@ -235,12 +230,12 @@ class SpinniesManager {
         if (!this.hasActiveSpinners()) {
             if (this.spin) {
                 this.setStreamOutput();
-                readline_1.default.moveCursor(this.stream, 0, this.lineCount);
+                readline.moveCursor(this.stream, 0, this.lineCount);
                 if (this.currentInterval) {
                     clearInterval(this.currentInterval);
                 }
                 this.isCursorHidden = false;
-                cli_cursor_1.default.show();
+                cliCursor.show();
             }
             this.spinners = {};
         }
@@ -248,12 +243,11 @@ class SpinniesManager {
     bindSigint() {
         process.removeAllListeners('SIGINT');
         process.on('SIGINT', () => {
-            cli_cursor_1.default.show();
-            readline_1.default.moveCursor(process.stderr, 0, this.lineCount);
+            cliCursor.show();
+            readline.moveCursor(process.stderr, 0, this.lineCount);
             process.exit(0);
         });
     }
 }
 const toExport = new SpinniesManager();
-exports.default = toExport;
-module.exports = toExport;
+export default toExport;

package/lib/ui/__tests__/removeAnsiCodes.test.d.ts

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

package/lib/ui/__tests__/removeAnsiCodes.test.js

@@ -0,0 +1,84 @@
+import { describe, it, expect } from 'vitest';
+import chalk from 'chalk';
+import { removeAnsiCodes } from '../removeAnsiCodes.js';
+describe('removeAnsiCodes', () => {
+    describe('basic functionality', () => {
+        it('should remove ANSI codes from colored text', () => {
+            const coloredText = chalk.red('Error message');
+            const cleanText = removeAnsiCodes(coloredText);
+            expect(cleanText).toBe('Error message');
+        });
+        it('should return unchanged text when no ANSI codes are present', () => {
+            const plainText = 'This is plain text';
+            const result = removeAnsiCodes(plainText);
+            expect(result).toBe('This is plain text');
+        });
+        it('should handle empty strings', () => {
+            const result = removeAnsiCodes('');
+            expect(result).toBe('');
+        });
+    });
+    describe('background colors', () => {
+        it('should remove background color codes', () => {
+            const text = chalk.bgRed('Text with red background');
+            expect(removeAnsiCodes(text)).toBe('Text with red background');
+        });
+        it('should remove multiple background colors', () => {
+            const text = chalk.bgBlue('Blue bg') + ' ' + chalk.bgYellow('Yellow bg');
+            expect(removeAnsiCodes(text)).toBe('Blue bg Yellow bg');
+        });
+    });
+    describe('text formatting', () => {
+        it('should remove bold formatting', () => {
+            const text = chalk.bold('Bold text');
+            expect(removeAnsiCodes(text)).toBe('Bold text');
+        });
+    });
+    describe('combined styles', () => {
+        it('should remove multiple formatting styles', () => {
+            const text = chalk.bold.red('Bold red text');
+            expect(removeAnsiCodes(text)).toBe('Bold red text');
+        });
+        it('should remove complex combinations', () => {
+            const text = chalk.bold.underline.red.bgYellow('Complex styling');
+            expect(removeAnsiCodes(text)).toBe('Complex styling');
+        });
+        it('should handle chained styles', () => {
+            const text = chalk.red('Red') + chalk.green(' Green') + chalk.blue(' Blue');
+            expect(removeAnsiCodes(text)).toBe('Red Green Blue');
+        });
+    });
+    describe('multiline text', () => {
+        it('should remove ANSI codes from multiline text', () => {
+            const text = chalk.red('Line 1\n') + chalk.green('Line 2\n') + chalk.blue('Line 3');
+            const expected = 'Line 1\nLine 2\nLine 3';
+            expect(removeAnsiCodes(text)).toBe(expected);
+        });
+        it('should handle mixed formatted and plain lines', () => {
+            const text = chalk.bold('Formatted line\n') +
+                'Plain line\n' +
+                chalk.italic('Another formatted line');
+            const expected = 'Formatted line\nPlain line\nAnother formatted line';
+            expect(removeAnsiCodes(text)).toBe(expected);
+        });
+    });
+    describe('edge cases', () => {
+        it('should handle text with only ANSI codes (no visible text)', () => {
+            const text = chalk.red('');
+            expect(removeAnsiCodes(text)).toBe('');
+        });
+        it('should handle multiple consecutive ANSI codes', () => {
+            // Create text with multiple style applications
+            const text = chalk.red(chalk.bold(chalk.underline('Heavily styled')));
+            expect(removeAnsiCodes(text)).toBe('Heavily styled');
+        });
+        it('should handle mixed content with spaces and special characters', () => {
+            const text = chalk.green('Success:') + ' ' + chalk.red('Error!') + ' @#$%^&*()';
+            expect(removeAnsiCodes(text)).toBe('Success: Error! @#$%^&*()');
+        });
+        it('should handle text with tabs and newlines', () => {
+            const text = chalk.yellow('\tTabbed text\n') + chalk.cyan('New line text');
+            expect(removeAnsiCodes(text)).toBe('\tTabbed text\nNew line text');
+        });
+    });
+});

package/lib/ui/boxen.js

@@ -1,30 +1,27 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.logInBox = logInBox;
-const logger_1 = require("./logger");
-const index_1 = require("./index");
-const logger_2 = require("@hubspot/local-dev-lib/logger");
-const en_1 = require("../../lang/en");
+import { uiLogger } from './logger.js';
+import { UI_COLORS } from './index.js';
+import { logger } from '@hubspot/local-dev-lib/logger';
+import { lib } from '../../lang/en.js';
 const defaultOptions = {
     titleAlignment: 'left',
-    borderColor: index_1.UI_COLORS.MARIGOLD,
+    borderColor: UI_COLORS.MARIGOLD,
     margin: 1,
     padding: 1,
     textAlignment: 'left',
     borderStyle: 'round',
 };
-async function logInBox({ contents, options, }) {
+export async function logInBox({ contents, options, }) {
     try {
         const boxen = (await import('boxen')).default;
-        logger_1.uiLogger.log(boxen(contents, { ...defaultOptions, ...options }));
+        uiLogger.log(boxen(contents, { ...defaultOptions, ...options }));
         return;
     }
     catch (error) {
-        logger_2.logger.debug(en_1.lib.boxen.failedToLoad);
+        logger.debug(lib.boxen.failedToLoad);
         if (options?.title) {
-            logger_1.uiLogger.log(options.title);
-            logger_1.uiLogger.log('');
+            uiLogger.log(options.title);
+            uiLogger.log('');
         }
-        logger_1.uiLogger.log(contents);
+        uiLogger.log(contents);
     }
 }