@hubspot/cli 7.6.0-beta.11 → 7.6.0-beta.13

package/lib/prompts/promptUtils.js

@@ -1,6 +1,8 @@
 import { confirm, Separator as _Separator, select, input, checkbox, password, number, } from '@inquirer/prompts';
 import { EXIT_CODES } from '../enums/exitCodes.js';
+import chalk from 'chalk';
 export const Separator = new _Separator();
+export const PROMPT_THEME = { prefix: { idle: chalk.green('?') } };
 function isUserCancellationError(error) {
     return error instanceof Error && error.name === 'ExitPromptError';
 }
@@ -103,6 +105,7 @@ function handleRawListPrompt(config) {
         pageSize: config.pageSize,
         default: config.default,
         loop: config.loop,
+        theme: PROMPT_THEME,
     }).then(resp => ({ [config.name]: resp }));
 }
 function handleNumberPrompt(config) {
@@ -110,6 +113,7 @@ function handleNumberPrompt(config) {
         message: config.message,
         default: config.default,
         validate: config.validate,
+        theme: PROMPT_THEME,
     }).then(resp => ({ [config.name]: resp }));
 }
 function handlePasswordPrompt(config) {
@@ -117,6 +121,7 @@ function handlePasswordPrompt(config) {
         message: config.message,
         mask: '*',
         validate: config.validate,
+        theme: PROMPT_THEME,
     }).then(resp => ({ [config.name]: resp }));
 }
 function handleCheckboxPrompt(config) {
@@ -127,6 +132,7 @@ function handleCheckboxPrompt(config) {
         pageSize: config.pageSize,
         validate: config.validate,
         loop: config.loop,
+        theme: PROMPT_THEME,
     }).then(resp => ({ [config.name]: resp }));
 }
 function handleConfirmPrompt(config) {
@@ -140,6 +146,7 @@ function handleInputPrompt(config) {
         default: config.default,
         validate: config.validate,
         transformer: config.transformer,
+        theme: PROMPT_THEME,
     }).then(resp => ({ [config.name]: resp }));
 }
 function handleSelectPrompt(config) {
@@ -150,6 +157,7 @@ function handleSelectPrompt(config) {
         default: config.default,
         pageSize: config.pageSize,
         loop: config.loop,
+        theme: PROMPT_THEME,
     }).then(resp => ({ [config.name]: resp }));
 }
 export async function confirmPrompt(message, options = {}) {
@@ -157,6 +165,7 @@ export async function confirmPrompt(message, options = {}) {
     const choice = await confirm({
         message,
         default: defaultAnswer,
+        theme: PROMPT_THEME,
     });
     return choice;
 }

package/lib/prompts/selectProjectTemplatePrompt.js

@@ -13,7 +13,7 @@ export async function selectProjectTemplatePrompt(promptOptions, projectTemplate
             if (template instanceof Separator || !template.value) {
                 return;
             }
-            if (promptOptions.features?.includes(template.value.type)) {
+            if (promptOptions.features?.includes(template.value.cliSelector || template.value.type)) {
                 if (template.disabled) {
                     throw new Error(`Cannot create project with template '${template.value.type}'. Reasons: ${template.disabled}`);
                 }

package/lib/theme/__tests__/migrate.test.d.ts

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

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/index.js

@@ -65,16 +65,13 @@ export function uiCommandReference(command, withQuotes = true) {
 }
 export function uiFeatureHighlight(features, title) {
     uiInfoSection(title ? title : i18n(`lib.ui.featureHighlight.defaultTitle`), () => {
-        features.forEach((c, i) => {
-            const featureKey = `lib.ui.featureHighlight.featureKeys.${c}`;
+        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`)),
             });
-            if (i !== 0) {
-                logger.log('');
-            }
-            logger.log(message);
+            logger.log(`  - ${message}`);
         });
     });
 }

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.d.ts

@@ -0,0 +1,32 @@
+import { TextContentResponse, Tool } from '../../types.js';
+import { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+declare const inputSchemaZodObject: z.ZodObject<{
+    absoluteCurrentWorkingDirectory: z.ZodString;
+    dest: z.ZodOptional<z.ZodString>;
+    functionsFolder: z.ZodOptional<z.ZodString>;
+    filename: z.ZodOptional<z.ZodString>;
+    endpointMethod: z.ZodOptional<z.ZodEnum<["DELETE", "GET", "PATCH", "POST", "PUT"]>>;
+    endpointPath: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    absoluteCurrentWorkingDirectory: string;
+    dest?: string | undefined;
+    functionsFolder?: string | undefined;
+    filename?: string | undefined;
+    endpointMethod?: "DELETE" | "GET" | "PATCH" | "POST" | "PUT" | undefined;
+    endpointPath?: string | undefined;
+}, {
+    absoluteCurrentWorkingDirectory: string;
+    dest?: string | undefined;
+    functionsFolder?: string | undefined;
+    filename?: string | undefined;
+    endpointMethod?: "DELETE" | "GET" | "PATCH" | "POST" | "PUT" | undefined;
+    endpointPath?: string | undefined;
+}>;
+export type HsCreateFunctionInputSchema = z.infer<typeof inputSchemaZodObject>;
+export declare class HsCreateFunctionTool extends Tool<HsCreateFunctionInputSchema> {
+    constructor(mcpServer: McpServer);
+    handler({ dest, functionsFolder, filename, endpointMethod, endpointPath, absoluteCurrentWorkingDirectory, }: HsCreateFunctionInputSchema): Promise<TextContentResponse>;
+    register(): RegisteredTool;
+}
+export {};

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

@@ -0,0 +1,96 @@
+import { Tool } from '../../types.js';
+import { z } from 'zod';
+import { absoluteCurrentWorkingDirectory } from '../project/constants.js';
+import { runCommandInDir } from '../../utils/project.js';
+import { formatTextContents, formatTextContent } from '../../utils/content.js';
+import { trackToolUsage } from '../../utils/toolUsageTracking.js';
+import { addFlag } from '../../utils/command.js';
+import { HTTP_METHODS } from '../../../types/Cms.js';
+const inputSchema = {
+    absoluteCurrentWorkingDirectory,
+    dest: z
+        .string()
+        .describe('The destination path where the function should be created on the current computer.')
+        .optional(),
+    functionsFolder: z
+        .string()
+        .describe('Folder name for function creation. Required for non-interactive function creation. If the user has not specified the folder name, ask them to provide it.')
+        .optional(),
+    filename: z
+        .string()
+        .describe('Function filename. Required for non-interactive function creation. If the user has not specified the filename, ask them to provide it.')
+        .optional(),
+    endpointMethod: z
+        .enum(HTTP_METHODS)
+        .describe(`HTTP method for the function endpoint. Must be one of: ${HTTP_METHODS.join(', ')}. Defaults to GET.`)
+        .optional(),
+    endpointPath: z
+        .string()
+        .describe('API endpoint path for the function. Required for non-interactive function creation. If the user has not specified the endpoint path, ask them to provide it.')
+        .optional(),
+};
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const inputSchemaZodObject = z.object({ ...inputSchema });
+const toolName = 'create-cms-function';
+export class HsCreateFunctionTool extends Tool {
+    constructor(mcpServer) {
+        super(mcpServer);
+    }
+    async handler({ dest, functionsFolder, filename, endpointMethod, endpointPath, absoluteCurrentWorkingDirectory, }) {
+        await trackToolUsage(toolName);
+        const content = [];
+        // Require functions folder
+        if (!functionsFolder) {
+            content.push(formatTextContent(`Ask the user to provide the folder name for the function.`));
+        }
+        // Require filename
+        if (!filename) {
+            content.push(formatTextContent(`Ask the user to provide the filename for the function.`));
+        }
+        // Require endpoint path
+        if (!endpointPath) {
+            content.push(formatTextContent(`Ask the user to provide the API endpoint path for the function.`));
+        }
+        // If we have missing required information, return the prompts
+        if (content.length > 0) {
+            return {
+                content,
+            };
+        }
+        // Build the command
+        let command = 'hs create function';
+        if (dest) {
+            command += ` "${dest}"`;
+        }
+        // Add function-specific flags
+        if (functionsFolder) {
+            command = addFlag(command, 'functions-folder', functionsFolder);
+        }
+        if (filename) {
+            command = addFlag(command, 'filename', filename);
+        }
+        if (endpointMethod) {
+            command = addFlag(command, 'endpoint-method', endpointMethod);
+        }
+        else {
+            command = addFlag(command, 'endpoint-method', 'GET');
+        }
+        if (endpointPath) {
+            command = addFlag(command, 'endpoint-path', endpointPath);
+        }
+        try {
+            const { stdout, stderr } = await runCommandInDir(absoluteCurrentWorkingDirectory, command);
+            return formatTextContents(stdout, stderr);
+        }
+        catch (error) {
+            return formatTextContents(error instanceof Error ? error.message : `${error}`);
+        }
+    }
+    register() {
+        return this.mcpServer.registerTool(toolName, {
+            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,
+        }, this.handler);
+    }
+}

package/mcp-server/tools/cms/HsCreateModuleTool.d.ts

@@ -0,0 +1,38 @@
+import { TextContentResponse, Tool } from '../../types.js';
+import { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+declare const inputSchemaZodObject: z.ZodObject<{
+    absoluteCurrentWorkingDirectory: z.ZodString;
+    userSuppliedName: z.ZodOptional<z.ZodString>;
+    dest: z.ZodOptional<z.ZodString>;
+    moduleLabel: z.ZodOptional<z.ZodString>;
+    reactType: z.ZodOptional<z.ZodBoolean>;
+    contentTypes: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    global: z.ZodOptional<z.ZodBoolean>;
+    availableForNewContent: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    absoluteCurrentWorkingDirectory: string;
+    dest?: string | undefined;
+    global?: boolean | undefined;
+    moduleLabel?: string | undefined;
+    reactType?: boolean | undefined;
+    contentTypes?: string | undefined;
+    availableForNewContent?: boolean | undefined;
+    userSuppliedName?: string | undefined;
+}, {
+    absoluteCurrentWorkingDirectory: string;
+    dest?: string | undefined;
+    global?: boolean | undefined;
+    moduleLabel?: string | undefined;
+    reactType?: boolean | undefined;
+    contentTypes?: string | undefined;
+    availableForNewContent?: boolean | undefined;
+    userSuppliedName?: string | undefined;
+}>;
+export type HsCreateModuleInputSchema = z.infer<typeof inputSchemaZodObject>;
+export declare class HsCreateModuleTool extends Tool<HsCreateModuleInputSchema> {
+    constructor(mcpServer: McpServer);
+    handler({ userSuppliedName, dest, moduleLabel, reactType, contentTypes, global, availableForNewContent, absoluteCurrentWorkingDirectory, }: HsCreateModuleInputSchema): Promise<TextContentResponse>;
+    register(): RegisteredTool;
+}
+export {};