@hubspot/cli 7.7.35-experimental.0 → 7.8.0-beta.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 { isV2Project } from '../../projects/platformVersion.js';
+import { fetchMigrationApps } from '../../app/migrate.js';
+import { getHasMigratableThemes, validateMigrationAppsAndThemes, handleThemesMigration, migrateThemes2025_2, } from '../migrate.js';
+import { lib } from '../../../lang/en.js';
+vi.mock('../../ui/logger.js');
+vi.mock('@hubspot/project-parsing-lib');
+vi.mock('../../prompts/promptUtils');
+vi.mock('../../projects/config');
+vi.mock('../../projects/ensureProjectExists');
+vi.mock('../../projects/platformVersion');
+vi.mock('../../app/migrate');
+const mockedGetProjectThemeDetails = getProjectThemeDetails;
+const mockedMigrateThemes = migrateThemes;
+const mockedConfirmPrompt = confirmPrompt;
+const mockedWriteProjectConfig = writeProjectConfig;
+const mockedEnsureProjectExists = ensureProjectExists;
+const mockedUseV3Api = isV2Project;
+const mockedFetchMigrationApps = fetchMigrationApps;
+const ACCOUNT_ID = 123;
+const PROJECT_NAME = 'Test Project';
+const PLATFORM_VERSION = '2025.2';
+const MOCK_PROJECT_DIR = '/mock/project/dir';
+const createLoadedProjectConfig = (name) => ({
+    projectConfig: { name, srcDir: 'src', platformVersion: '2024.1' },
+    projectDir: MOCK_PROJECT_DIR,
+});
+describe('lib/theme/migrate', () => {
+    beforeEach(() => {
+        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 { isV2Project } from '../projects/platformVersion.js';
+import { confirmPrompt } from '../prompts/promptUtils.js';
+import { fetchMigrationApps } from '../app/migrate.js';
+export async function getHasMigratableThemes(projectConfig) {
+    if (!projectConfig?.projectConfig?.name || !projectConfig?.projectDir) {
+        return { hasMigratableThemes: false, migratableThemesCount: 0 };
+    }
+    const projectSrcDir = path.resolve(projectConfig.projectDir, projectConfig.projectConfig.srcDir);
+    const { legacyThemeDetails, legacyReactThemeDetails } = await getProjectThemeDetails(projectSrcDir);
+    return {
+        hasMigratableThemes: legacyThemeDetails.length > 0 || legacyReactThemeDetails.length > 0,
+        migratableThemesCount: legacyThemeDetails.length + legacyReactThemeDetails.length,
+    };
+}
+export async function validateMigrationAppsAndThemes(hasApps, projectConfig) {
+    if (isV2Project(projectConfig?.projectConfig?.platformVersion)) {
+        throw new Error(lib.migrate.errors.project.themesAlreadyMigrated);
+    }
+    if (hasApps > 0 && projectConfig) {
+        throw new Error(lib.migrate.errors.project.themesAndAppsNotAllowed);
+    }
+    if (!projectConfig) {
+        throw new Error(lib.migrate.errors.project.noProjectForThemesMigration);
+    }
+}
+export async function handleThemesMigration(projectConfig, platformVersion) {
+    if (!projectConfig?.projectDir || !projectConfig?.projectConfig?.srcDir) {
+        throw new Error(lib.migrate.errors.project.invalidConfig);
+    }
+    const projectSrcDir = path.resolve(projectConfig.projectDir, projectConfig.projectConfig.srcDir);
+    let migrated = false;
+    let failureReason;
+    try {
+        const migrationResult = await migrateThemes(projectConfig.projectDir, projectSrcDir);
+        migrated = migrationResult.migrated;
+        failureReason = migrationResult.failureReason;
+    }
+    catch (error) {
+        debugError(error);
+        throw new Error(lib.migrate.errors.project.failedToMigrateThemes);
+    }
+    if (!migrated) {
+        throw new Error(failureReason || lib.migrate.errors.project.failedToMigrateThemes);
+    }
+    const newProjectConfig = { ...projectConfig.projectConfig };
+    newProjectConfig.platformVersion = platformVersion;
+    const projectConfigPath = path.join(projectConfig.projectDir, PROJECT_CONFIG_FILE);
+    const success = writeProjectConfig(projectConfigPath, newProjectConfig);
+    if (!success) {
+        throw new Error(lib.migrate.errors.project.failedToUpdateProjectConfig);
+    }
+    uiLogger.log('');
+    uiLogger.log(lib.migrate.success.themesMigrationSuccess(platformVersion));
+}
+export async function migrateThemes2025_2(derivedAccountId, options, themeCount, projectConfig) {
+    SpinniesManager.init();
+    if (!projectConfig?.projectConfig || !projectConfig?.projectDir) {
+        throw new Error(lib.migrate.errors.project.invalidConfig);
+    }
+    const { projectExists } = await ensureProjectExists(derivedAccountId, projectConfig.projectConfig.name, { allowCreate: false, noLogs: true });
+    if (!projectExists) {
+        throw new Error(lib.migrate.errors.project.doesNotExist(derivedAccountId));
+    }
+    SpinniesManager.add('checkingForMigratableComponents', {
+        text: lib.migrate.spinners.checkingForMigratableComponents,
+    });
+    const { migratableApps, unmigratableApps } = await fetchMigrationApps(derivedAccountId, options.platformVersion, projectConfig);
+    const hasApps = [...migratableApps, ...unmigratableApps].length;
+    SpinniesManager.remove('checkingForMigratableComponents');
+    await validateMigrationAppsAndThemes(hasApps, projectConfig);
+    uiLogger.log(lib.migrate.prompt.themesMigration(themeCount));
+    const proceed = await confirmPrompt(lib.migrate.prompt.proceed, {
+        defaultAnswer: false,
+    });
+    if (proceed) {
+        await handleThemesMigration(projectConfig, options.platformVersion);
+    }
+    else {
+        uiLogger.log(lib.migrate.exitWithoutMigrating);
+    }
+}

package/lib/ui/SpinniesManager.d.ts

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

package/lib/ui/SpinniesManager.js

@@ -19,6 +19,7 @@ function safeColor(text, color) {
     return text;
 }
 class SpinniesManager {
+    disableOutput = false;
     options;
     spinners = {};
     isCursorHidden = false;
@@ -61,6 +62,9 @@ class SpinniesManager {
         this.lineCount = 0;
         this.currentFrameIndex = 0;
     }
+    setDisableOutput(disableOutput) {
+        this.disableOutput = disableOutput;
+    }
     pick(name) {
         return this.spinners?.[name];
     }
@@ -142,6 +146,9 @@ class SpinniesManager {
         this.spinners[name] = { ...this.spinners[name], ...options, status };
     }
     updateSpinnerState() {
+        if (this.disableOutput) {
+            return;
+        }
         if (this.spin) {
             if (this.currentInterval) {
                 clearInterval(this.currentInterval);

package/lib/ui/boxen.js

@@ -1,6 +1,5 @@
 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',
@@ -17,7 +16,7 @@ export async function logInBox({ contents, options, }) {
         return;
     }
     catch (error) {
-        logger.debug(lib.boxen.failedToLoad);
+        uiLogger.debug(lib.boxen.failedToLoad);
         if (options?.title) {
             uiLogger.log(options.title);
             uiLogger.log('');

package/lib/ui/git.js

@@ -1,22 +1,25 @@
 import os from 'os';
 import { checkGitInclusion } from '@hubspot/local-dev-lib/gitignore';
-import { logger } from '@hubspot/local-dev-lib/logger';
-import { i18n } from '../lang.js';
+import { uiLogger } from './logger.js';
+import { lib } from '../../lang/en.js';
+import { uiLine } from './index.js';
 export function checkAndWarnGitInclusion(configPath) {
     try {
         const { inGit, configIgnored } = checkGitInclusion(configPath);
         if (!inGit || configIgnored)
             return;
-        logger.warn(i18n(`lib.ui.git.securityIssue`));
-        logger.warn(i18n(`lib.ui.git.configFileTracked`));
-        logger.warn(i18n(`lib.ui.git.fileName`, { configPath }));
-        logger.warn(i18n(`lib.ui.git.remediate`));
-        logger.warn(i18n(`lib.ui.git.moveConfig`, { homeDir: os.homedir() }));
-        logger.warn(i18n(`lib.ui.git.addGitignore`, { configPath }));
-        logger.warn(i18n(`lib.ui.git.noRemote`));
+        uiLine();
+        uiLogger.warn(lib.ui.git.securityIssue);
+        uiLogger.log(lib.ui.git.configFileTracked);
+        uiLogger.log(lib.ui.git.fileName(configPath));
+        uiLogger.log('');
+        uiLogger.log(lib.ui.git.moveConfig(os.homedir()));
+        uiLogger.log(lib.ui.git.addGitignore(configPath));
+        uiLogger.log(lib.ui.git.noRemote);
+        uiLine();
     }
     catch (e) {
         // fail silently
-        logger.debug(i18n(`lib.ui.git.checkFailed`));
+        uiLogger.debug(lib.ui.git.checkFailed);
     }
 }

package/lib/ui/index.js

@@ -1,9 +1,9 @@
 import chalk from 'chalk';
 import { getAccountConfig } from '@hubspot/local-dev-lib/config';
-import { logger } from '@hubspot/local-dev-lib/logger';
+import { uiLogger } from './logger.js';
 import { supportsHyperlinkModule } from './supportHyperlinks.js';
 import { supportsColor } from './supportsColor.js';
-import { i18n } from '../lang.js';
+import { uiMessages } from './uiMessages.js';
 import { HUBSPOT_ACCOUNT_TYPE_STRINGS } from '@hubspot/local-dev-lib/constants/config';
 export const UI_COLORS = {
     SORBET: '#FF8F59',
@@ -11,7 +11,7 @@ export const UI_COLORS = {
     MARIGOLD_DARK: '#dbae60',
 };
 export function uiLine() {
-    logger.log('-'.repeat(50));
+    uiLogger.log('-'.repeat(50));
 }
 export function getTerminalUISupport() {
     return {
@@ -50,10 +50,10 @@ export function uiAccountDescription(accountId, bold = true) {
 }
 export function uiInfoSection(title, logContent) {
     uiLine();
-    logger.log(chalk.bold(title));
-    logger.log('');
+    uiLogger.log(chalk.bold(title));
+    uiLogger.log('');
     logContent();
-    logger.log('');
+    uiLogger.log('');
     uiLine();
 }
 export function uiCommandReference(command, withQuotes = true) {
@@ -64,65 +64,66 @@ export function uiCommandReference(command, withQuotes = true) {
         : commandReference);
 }
 export function uiFeatureHighlight(features, title) {
-    uiInfoSection(title ? title : i18n(`lib.ui.featureHighlight.defaultTitle`), () => {
+    uiInfoSection(title ? title : uiMessages.featureHighlight.defaultTitle, () => {
         features.forEach(feature => {
-            const featureKey = `lib.ui.featureHighlight.featureKeys.${feature}`;
-            const message = i18n(`${featureKey}.message`, {
-                command: uiCommandReference(i18n(`${featureKey}.command`)),
-                link: uiLink(i18n(`${featureKey}.linkText`), i18n(`${featureKey}.url`)),
-            });
-            logger.log(`  - ${message}`);
+            const featureConfig = uiMessages.featureHighlight.featureKeys[feature];
+            if (!featureConfig) {
+                uiLogger.debug(`Feature config not found for: ${feature}`);
+                return;
+            }
+            let message;
+            if ('linkText' in featureConfig && 'url' in featureConfig) {
+                // linkText + url (for sampleProjects)
+                message = featureConfig.message(uiLink(featureConfig.linkText, featureConfig.url));
+            }
+            else if ('command' in featureConfig && 'message' in featureConfig) {
+                // Command + Message function (most cases)
+                message = featureConfig.message(uiCommandReference(featureConfig.command));
+            }
+            else {
+                // Message only (for projectCommandTip)
+                message = featureConfig.message;
+            }
+            uiLogger.log(`  - ${message}`);
         });
     });
 }
 export function uiBetaTag(message, log = true) {
-    const tag = i18n(`lib.ui.betaTag`);
+    const tag = uiMessages.betaTag;
     const result = `${tag} ${message}`;
     if (log) {
-        logger.log(result);
+        uiLogger.log(result);
         return;
     }
     return result;
 }
 export function uiDeprecatedTag(message, log = true) {
-    const tag = i18n(`lib.ui.deprecatedTag`);
+    const tag = uiMessages.deprecatedTag;
     const result = `${tag} ${message}`;
     if (log) {
-        logger.log(result);
+        uiLogger.log(result);
         return;
     }
     return result;
 }
 export function uiCommandDisabledBanner(command, url, message) {
     const tag = message ||
-        i18n(`lib.ui.disabledMessage`, {
-            command: uiCommandReference(command),
-            url: url ? uiLink(i18n(`lib.ui.disabledUrlText`), url) : '',
-            npmCommand: uiCommandReference('npm i -g @hubspot/cli@latest'),
-        });
-    logger.log();
+        `The ${uiCommandReference(command)} command is disabled. Run ${uiCommandReference('npm i -g @hubspot/cli@latest')} to update to the latest HubSpot CLI version. ${url ? uiLink('See all HubSpot CLI commands here.', url) : ''}`;
+    uiLogger.log('');
     uiLine();
-    logger.error(tag);
+    uiLogger.error(tag);
     uiLine();
-    logger.log();
+    uiLogger.log('');
 }
 export function uiDeprecatedDescription(message, command, url) {
-    const tag = i18n(`lib.ui.deprecatedDescription`, {
-        message,
-        command: uiCommandReference(command),
-        url: url ? uiLink(i18n(`lib.ui.deprecatedUrlText`), url) : '',
-    });
+    const tag = message || uiMessages.disabledMessage(command, url);
     return uiDeprecatedTag(tag);
 }
 export function uiDeprecatedMessage(command, url, message) {
-    const tag = message ||
-        i18n(`lib.ui.deprecatedMessage`, {
-            command: uiCommandReference(command),
-            url: url ? uiLink(i18n(`lib.ui.deprecatedUrlText`), url) : '',
-        });
-    logger.log();
+    const tag = uiMessages.deprecatedDescription(message || '', command, url);
+    uiLogger.log('');
     uiDeprecatedTag(tag);
-    logger.log();
+    uiLogger.log('');
 }
 export function indent(level) {
     const indentation = '  ';

package/lib/ui/serverlessFunctionLogs.js

@@ -1,7 +1,8 @@
 import moment from 'moment';
 import chalk from 'chalk';
-import { logger, Styles } from '@hubspot/local-dev-lib/logger';
-import { i18n } from '../lang.js';
+import { Styles } from '@hubspot/local-dev-lib/logger';
+import { uiLogger } from './logger.js';
+import { lib } from '../../lang/en.js';
 const SEPARATOR = ' - ';
 const LOG_STATUS_COLORS = {
     SUCCESS: Styles.success,
@@ -56,9 +57,7 @@ function processLog(log, options) {
         return logHandler[log.status](log, options);
     }
     catch (e) {
-        logger.error(i18n(`lib.ui.serverlessFunctionLogs.unableToProcessLog`, {
-            log: JSON.stringify(log),
-        }));
+        uiLogger.error(lib.ui.serverlessFunctionLogs.unableToProcessLog(JSON.stringify(log)));
     }
 }
 function isLogsResponse(logsResp) {
@@ -70,7 +69,7 @@ function isLogsResponse(logsResp) {
 function processLogs(logsResp, options) {
     const isLogsResp = isLogsResponse(logsResp);
     if (!logsResp || (isLogsResp && logsResp.results.length === 0)) {
-        return i18n(`lib.ui.serverlessFunctionLogs.noLogsFound`);
+        return lib.ui.serverlessFunctionLogs.noLogsFound;
     }
     else if (isLogsResp) {
         return logsResp
@@ -82,5 +81,8 @@ function processLogs(logsResp, options) {
     return processLog(logsResp, options);
 }
 export function outputLogs(logsResp, options) {
-    logger.log(processLogs(logsResp, options));
+    const result = processLogs(logsResp, options);
+    if (result) {
+        uiLogger.log(result);
+    }
 }