@hubspot/cli 7.8.0-experimental.0 → 7.8.1-experimental.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.js

@@ -7,8 +7,10 @@ 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.
 **/
+import readline from 'readline';
 import chalk from 'chalk';
-import { colorOptions, purgeSpinnerOptions, purgeSpinnersOptions, SPINNERS, terminalSupportsUnicode, } from './spinniesUtils.js';
+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[color];
     if (typeof chalkFn === 'function') {
@@ -34,10 +36,14 @@ class SpinniesManager {
             succeedColor: 'green',
             failColor: 'red',
             spinner: terminalSupportsUnicode() ? SPINNERS.dots : SPINNERS.dashes,
-            disableSpins: true,
+            disableSpins: false,
             ...purgeSpinnersOptions(options),
         };
-        this.spin = false;
+        this.spin =
+            !this.options.disableSpins &&
+                !process.env.CI &&
+                process.stderr &&
+                process.stderr.isTTY;
         if (!this.hasAnySpinners()) {
             this.resetState();
         }
@@ -135,7 +141,22 @@ class SpinniesManager {
         status = status || 'spinning';
         this.spinners[name] = { ...this.spinners[name], ...options, status };
     }
-    updateSpinnerState() { }
+    updateSpinnerState() {
+        if (this.spin) {
+            if (this.currentInterval) {
+                clearInterval(this.currentInterval);
+            }
+            this.currentInterval = this.loopStream();
+            if (!this.isCursorHidden) {
+                cliCursor.hide();
+            }
+            this.isCursorHidden = true;
+            this.checkIfActiveSpinners();
+        }
+        else {
+            this.setRawStreamOutput();
+        }
+    }
     loopStream() {
         const frames = this.options.spinner?.frames || SPINNERS.dots.frames;
         const interval = this.options.spinner?.interval || SPINNERS.dots.interval;
@@ -147,10 +168,86 @@ class SpinniesManager {
                     : ++this.currentFrameIndex;
         }, interval);
     }
-    setStreamOutput(frame = '') { }
-    setRawStreamOutput() { }
-    checkIfActiveSpinners() { }
-    bindSigint() { }
+    setStreamOutput(frame = '') {
+        let output = '';
+        const linesLength = [];
+        const hasActiveSpinners = this.hasActiveSpinners();
+        Object.values(this.spinners).forEach(spinner => {
+            let { text } = 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 = breakText(text, prefixLength);
+                const colorizedFrame = safeColor(frame, spinnerColor);
+                const colorizedText = safeColor(text, color);
+                line = `${colorizedFrame} ${colorizedText}`;
+            }
+            else {
+                if (status === 'succeed') {
+                    prefixLength += succeedPrefix.length + 1;
+                    if (hasActiveSpinners) {
+                        text = breakText(text, prefixLength);
+                    }
+                    const colorizedText = safeColor(text, succeedColor);
+                    line = `${chalk.green(succeedPrefix)} ${colorizedText}`;
+                }
+                else if (status === 'fail') {
+                    prefixLength += failPrefix.length + 1;
+                    if (hasActiveSpinners) {
+                        text = breakText(text, prefixLength);
+                    }
+                    const colorizedText = safeColor(text, failColor);
+                    line = `${chalk.red(failPrefix)} ${colorizedText}`;
+                }
+                else {
+                    if (hasActiveSpinners) {
+                        text = breakText(text, prefixLength);
+                    }
+                    line = safeColor(text, color);
+                }
+            }
+            linesLength.push(...getLinesLength(text, prefixLength));
+            output += indent ? `${' '.repeat(indent)}${line}\n` : `${line}\n`;
+        });
+        if (!hasActiveSpinners) {
+            readline.clearScreenDown(this.stream);
+        }
+        writeStream(this.stream, output, linesLength);
+        if (hasActiveSpinners) {
+            cleanStream(this.stream, linesLength);
+        }
+        this.lineCount = linesLength.length;
+    }
+    setRawStreamOutput() {
+        Object.values(this.spinners).forEach(i => {
+            process.stderr.write(`- ${i.text}\n`);
+        });
+    }
+    checkIfActiveSpinners() {
+        if (!this.hasActiveSpinners()) {
+            if (this.spin) {
+                this.setStreamOutput();
+                readline.moveCursor(this.stream, 0, this.lineCount);
+                if (this.currentInterval) {
+                    clearInterval(this.currentInterval);
+                }
+                this.isCursorHidden = false;
+                cliCursor.show();
+            }
+            this.spinners = {};
+        }
+    }
+    bindSigint() {
+        process.removeAllListeners('SIGINT');
+        process.on('SIGINT', () => {
+            cliCursor.show();
+            readline.moveCursor(process.stderr, 0, this.lineCount);
+            process.exit(0);
+        });
+    }
 }
 const toExport = new SpinniesManager();
 export default toExport;

package/lib/usageTracking.js

@@ -44,7 +44,7 @@ export async function trackCommandUsage(command, meta = {}, accountId) {
         action: 'cli-command',
         command,
         authType,
-        ...meta,
+        meta,
         accountId,
     });
 }
@@ -133,12 +133,12 @@ async function trackCliInteraction({ action, accountId, command, authType, meta
             }
         }
         try {
+            logger.debug('Sent usage tracking command event: %o', usageTrackingEvent);
             return trackUsage('cli-interaction', EventClass.INTERACTION, usageTrackingEvent, accountId);
         }
         catch (error) {
             debugError(error);
         }
-        logger.debug('Sent usage tracking command event: %o', usageTrackingEvent);
     }
     catch (e) {
         debugError(e);

package/mcp-server/tools/cms/HsCreateFunctionTool.js

@@ -31,7 +31,7 @@ const inputSchema = {
 };
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 const inputSchemaZodObject = z.object({ ...inputSchema });
-const toolName = 'create-hubspot-cms-function';
+const toolName = 'create-cms-function';
 export class HsCreateFunctionTool extends Tool {
     constructor(mcpServer) {
         super(mcpServer);

package/mcp-server/tools/cms/HsCreateModuleTool.js

@@ -47,7 +47,7 @@ const inputSchema = {
 };
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 const inputSchemaZodObject = z.object({ ...inputSchema });
-const toolName = 'create-hubspot-cms-module';
+const toolName = 'create-cms-module';
 export class HsCreateModuleTool extends Tool {
     constructor(mcpServer) {
         super(mcpServer);

package/mcp-server/tools/cms/HsCreateTemplateTool.js

@@ -23,7 +23,7 @@ const inputSchema = {
 };
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 const inputSchemaZodObject = z.object({ ...inputSchema });
-const toolName = 'create-hubspot-cms-template';
+const toolName = 'create-cms-template';
 export class HsCreateTemplateTool extends Tool {
     constructor(mcpServer) {
         super(mcpServer);

package/mcp-server/tools/cms/HsFunctionLogsTool.js

@@ -26,7 +26,7 @@ const inputSchema = {
 };
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 const inputSchemaZodObject = z.object({ ...inputSchema });
-const toolName = 'get-hubspot-cms-serverless-function-logs';
+const toolName = 'get-cms-serverless-function-logs';
 export class HsFunctionLogsTool extends Tool {
     constructor(mcpServer) {
         super(mcpServer);
@@ -69,7 +69,7 @@ export class HsFunctionLogsTool extends Tool {
     register() {
         return this.mcpServer.registerTool(toolName, {
             title: 'Get HubSpot CMS serverless function logs for an endpoint',
-            description: 'Retrieve logs for HubSpot CMS serverless functions. Use this tool to help debug issues with serverless functions by reading the production logs. Supports various options like latest, compact, and limiting results. Use after listing functions with list-hubspot-cms-serverless-functions to get the endpoint path.',
+            description: 'Retrieve logs for HubSpot CMS serverless functions. Use this tool to help debug issues with serverless functions by reading the production logs. Supports various options like latest, compact, and limiting results. Use after listing functions with list-cms-serverless-functions to get the endpoint path.',
             inputSchema,
         }, this.handler);
     }

package/mcp-server/tools/cms/HsListFunctionsTool.js

@@ -18,7 +18,7 @@ const inputSchema = {
 };
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 const inputSchemaZodObject = z.object({ ...inputSchema });
-const toolName = 'list-hubspot-cms-serverless-functions';
+const toolName = 'list-cms-serverless-functions';
 export class HsListFunctionsTool extends Tool {
     constructor(mcpServer) {
         super(mcpServer);

package/mcp-server/tools/cms/HsListTool.js

@@ -18,7 +18,7 @@ const inputSchema = {
 };
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 const inputSchemaZodObject = z.object({ ...inputSchema });
-const toolName = 'list-hubspot-cms-remote-contents';
+const toolName = 'list-cms-remote-contents';
 export class HsListTool extends Tool {
     constructor(mcpServer) {
         super(mcpServer);

package/mcp-server/tools/cms/__tests__/HsCreateFunctionTool.test.js

@@ -28,7 +28,7 @@ describe('HsCreateFunctionTool', () => {
     describe('register', () => {
         it('should register the tool with the MCP server', () => {
             const result = tool.register();
-            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('create-hubspot-cms-function', {
+            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('create-cms-function', {
                 title: 'Create HubSpot CMS Serverless Function',
                 description: `Creates a new HubSpot CMS serverless function using the hs create function command. Functions can be created non-interactively by specifying functionsFolder, filename, and endpointPath. Supports all HTTP methods (${HTTP_METHODS.join(', ')}).`,
                 inputSchema: expect.any(Object),

package/mcp-server/tools/cms/__tests__/HsCreateModuleTool.test.js

@@ -27,7 +27,7 @@ describe('HsCreateModuleTool', () => {
     describe('register', () => {
         it('should register the tool with the MCP server', () => {
             const result = tool.register();
-            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('create-hubspot-cms-module', {
+            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('create-cms-module', {
                 title: 'Create HubSpot CMS Module',
                 description: 'Creates a new HubSpot CMS module using the hs create module command. Modules can be created non-interactively by specifying moduleLabel and other module options. You can create either HubL or React modules by setting the reactType parameter.',
                 inputSchema: expect.any(Object),

package/mcp-server/tools/cms/__tests__/HsCreateTemplateTool.test.js

@@ -28,7 +28,7 @@ describe('HsCreateTemplateTool', () => {
     describe('register', () => {
         it('should register the tool with the MCP server', () => {
             const result = tool.register();
-            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('create-hubspot-cms-template', {
+            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('create-cms-template', {
                 title: 'Create HubSpot CMS Template',
                 description: `Creates a new HubSpot CMS template using the hs create template command. Templates can be created non-interactively by specifying templateType. Supports all template types including: ${TEMPLATE_TYPES.join(', ')}.`,
                 inputSchema: expect.any(Object),

package/mcp-server/tools/cms/__tests__/HsFunctionLogsTool.test.js

@@ -27,9 +27,9 @@ describe('HsFunctionLogsTool', () => {
     describe('register', () => {
         it('should register the tool with the MCP server', () => {
             const result = tool.register();
-            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('get-hubspot-cms-serverless-function-logs', expect.objectContaining({
+            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('get-cms-serverless-function-logs', expect.objectContaining({
                 title: 'Get HubSpot CMS serverless function logs for an endpoint',
-                description: 'Retrieve logs for HubSpot CMS serverless functions. Use this tool to help debug issues with serverless functions by reading the production logs. Supports various options like latest, compact, and limiting results. Use after listing functions with list-hubspot-cms-serverless-functions to get the endpoint path.',
+                description: 'Retrieve logs for HubSpot CMS serverless functions. Use this tool to help debug issues with serverless functions by reading the production logs. Supports various options like latest, compact, and limiting results. Use after listing functions with list-cms-serverless-functions to get the endpoint path.',
                 inputSchema: expect.any(Object),
             }), expect.any(Function));
             expect(result).toBe(mockRegisteredTool);

package/mcp-server/tools/cms/__tests__/HsListFunctionsTool.test.js

@@ -27,7 +27,7 @@ describe('HsListFunctionsTool', () => {
     describe('register', () => {
         it('should register the tool with the MCP server', () => {
             const result = tool.register();
-            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('list-hubspot-cms-serverless-functions', {
+            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('list-cms-serverless-functions', {
                 title: 'List HubSpot CMS Serverless Functions',
                 description: 'Get a list of all serverless functions deployed in a HubSpot portal/account. Shows function routes, HTTP methods, secrets, and timestamps.',
                 inputSchema: expect.any(Object),

package/mcp-server/tools/cms/__tests__/HsListTool.test.js

@@ -27,7 +27,7 @@ describe('HsListTool', () => {
     describe('register', () => {
         it('should register the tool with the MCP server', () => {
             const result = tool.register();
-            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('list-hubspot-cms-remote-contents', {
+            expect(mockMcpServer.registerTool).toHaveBeenCalledWith('list-cms-remote-contents', {
                 title: 'List HubSpot CMS Directory Contents',
                 description: 'List remote contents of a HubSpot CMS directory.',
                 inputSchema: expect.any(Object),