@hubspot/cli 7.7.32-experimental.0 → 7.7.34-experimental.0

package/lib/prompts/__tests__/projectAddPrompt.test.js

@@ -0,0 +1,143 @@
+import { Separator } from '@inquirer/prompts';
+import { projectAddPromptV3 } from '../projectAddPrompt.js';
+import { promptUser } from '../promptUtils.js';
+vi.mock('../promptUtils');
+const mockedPromptUser = vi.mocked(promptUser);
+describe('lib/prompts/projectAddPrompt', () => {
+    const mockComponentTemplate = {
+        label: 'Test Module',
+        path: 'test-module',
+        type: 'module',
+        supportedAuthTypes: ['oauth'],
+        supportedDistributions: ['private'],
+    };
+    const mockComponentTemplateWithCliSelector = {
+        label: 'Workflow Action Tool',
+        path: 'workflow-action-tool',
+        type: 'workflow-action',
+        cliSelector: 'workflow-action-tool',
+        supportedAuthTypes: ['oauth'],
+        supportedDistributions: ['private'],
+    };
+    describe('projectAddPromptV3()', () => {
+        beforeEach(() => {
+            // Mock returns empty result, logic will use selectedComponents when selectedFeatures provided
+            mockedPromptUser.mockResolvedValue({});
+        });
+        it('should select component based on cliSelector when provided', async () => {
+            const templateChoice = {
+                name: 'Workflow Action Tool',
+                value: mockComponentTemplateWithCliSelector,
+            };
+            const components = [templateChoice];
+            const selectedFeatures = ['workflow-action-tool'];
+            const result = await projectAddPromptV3(components, selectedFeatures);
+            expect(result.componentTemplate).toEqual([
+                mockComponentTemplateWithCliSelector,
+            ]);
+            expect(mockedPromptUser).toHaveBeenCalledWith([
+                expect.objectContaining({
+                    name: 'componentTemplate',
+                    when: false, // selectedFeatures provided, so skip prompt
+                }),
+            ]);
+        });
+        it('should select component based on type when cliSelector not provided', async () => {
+            const templateChoice = {
+                name: 'Test Module',
+                value: mockComponentTemplate,
+            };
+            const components = [templateChoice];
+            const selectedFeatures = ['module'];
+            const result = await projectAddPromptV3(components, selectedFeatures);
+            expect(result.componentTemplate).toEqual([mockComponentTemplate]);
+            expect(mockedPromptUser).toHaveBeenCalledWith([
+                expect.objectContaining({
+                    name: 'componentTemplate',
+                    when: false, // selectedFeatures provided and selectedComponents found
+                }),
+            ]);
+        });
+        it('should prefer cliSelector over type when both are available', async () => {
+            const templateChoice = {
+                name: 'Workflow Action Tool',
+                value: mockComponentTemplateWithCliSelector,
+            };
+            const components = [templateChoice];
+            const selectedFeatures = ['workflow-action-tool']; // matches cliSelector
+            const result = await projectAddPromptV3(components, selectedFeatures);
+            expect(result.componentTemplate).toEqual([
+                mockComponentTemplateWithCliSelector,
+            ]);
+        });
+        it('should not select component when neither cliSelector nor type matches', async () => {
+            const templateChoice = {
+                name: 'Test Module',
+                value: mockComponentTemplate,
+            };
+            const components = [templateChoice];
+            const selectedFeatures = ['non-matching-feature'];
+            mockedPromptUser.mockResolvedValue({ componentTemplate: [] });
+            const result = await projectAddPromptV3(components, selectedFeatures);
+            expect(result.componentTemplate).toEqual([]);
+        });
+        it('should throw error when selected feature component is disabled', async () => {
+            const disabledTemplateChoice = {
+                name: 'Disabled Component',
+                value: mockComponentTemplateWithCliSelector,
+                disabled: 'Component is disabled for testing',
+            };
+            const components = [disabledTemplateChoice];
+            const selectedFeatures = ['workflow-action-tool'];
+            await expect(projectAddPromptV3(components, selectedFeatures)).rejects.toThrow(/Cannot.*feature.*workflow-action/);
+        });
+        it('should handle multiple components with mixed cliSelector availability', async () => {
+            const choice1 = {
+                name: 'Test Module',
+                value: mockComponentTemplate,
+            };
+            const choice2 = {
+                name: 'Workflow Action Tool',
+                value: mockComponentTemplateWithCliSelector,
+            };
+            const components = [choice1, choice2];
+            const selectedFeatures = ['module', 'workflow-action-tool'];
+            const result = await projectAddPromptV3(components, selectedFeatures);
+            expect(result.componentTemplate).toEqual([
+                mockComponentTemplate,
+                mockComponentTemplateWithCliSelector,
+            ]);
+        });
+        it('should skip Separator instances when processing components', async () => {
+            const separator = new Separator();
+            const templateChoice = {
+                name: 'Test Module',
+                value: mockComponentTemplate,
+            };
+            const components = [separator, templateChoice];
+            const selectedFeatures = ['module'];
+            const result = await projectAddPromptV3(components, selectedFeatures);
+            expect(result.componentTemplate).toEqual([mockComponentTemplate]);
+        });
+        it('should prompt user when no selectedFeatures provided', async () => {
+            const templateChoice = {
+                name: 'Test Module',
+                value: mockComponentTemplate,
+            };
+            const components = [templateChoice];
+            const selectedFeatures = undefined;
+            mockedPromptUser.mockResolvedValue({
+                componentTemplate: [mockComponentTemplate],
+            });
+            const result = await projectAddPromptV3(components, selectedFeatures);
+            expect(mockedPromptUser).toHaveBeenCalledWith([
+                expect.objectContaining({
+                    name: 'componentTemplate',
+                    type: 'checkbox',
+                    choices: components,
+                }),
+            ]);
+            expect(result.componentTemplate).toEqual([mockComponentTemplate]);
+        });
+    });
+});

package/lib/prompts/__tests__/selectProjectTemplatePrompt.test.d.ts

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

package/lib/prompts/__tests__/selectProjectTemplatePrompt.test.js

@@ -0,0 +1,160 @@
+import { Separator } from '@inquirer/prompts';
+import { selectProjectTemplatePrompt } from '../selectProjectTemplatePrompt.js';
+import { promptUser } from '../promptUtils.js';
+vi.mock('../promptUtils');
+const mockedPromptUser = vi.mocked(promptUser);
+describe('lib/prompts/selectProjectTemplatePrompt', () => {
+    const mockComponentTemplate = {
+        label: 'Test Module',
+        path: 'test-module',
+        type: 'module',
+        supportedAuthTypes: ['oauth'],
+        supportedDistributions: ['private'],
+    };
+    const mockComponentTemplateWithCliSelector = {
+        label: 'Workflow Action Tool',
+        path: 'workflow-action-tool',
+        type: 'workflow-action',
+        cliSelector: 'workflow-action-tool',
+        supportedAuthTypes: ['oauth'],
+        supportedDistributions: ['private'],
+    };
+    beforeEach(() => {
+        mockedPromptUser.mockResolvedValue({});
+    });
+    describe('selectProjectTemplatePrompt with component templates', () => {
+        it('should select component based on cliSelector when provided', async () => {
+            const templateChoice = {
+                name: 'Workflow Action Tool',
+                value: mockComponentTemplateWithCliSelector,
+            };
+            const componentTemplates = [templateChoice];
+            const promptOptions = {
+                features: ['workflow-action-tool'],
+            };
+            const result = await selectProjectTemplatePrompt(promptOptions, undefined, componentTemplates);
+            expect(result.componentTemplates).toEqual([
+                mockComponentTemplateWithCliSelector,
+            ]);
+            expect(mockedPromptUser).toHaveBeenCalledWith([
+                expect.objectContaining({ name: 'projectTemplate' }),
+                expect.objectContaining({ name: 'componentTemplates' }),
+            ]);
+        });
+        it('should select component based on type when cliSelector not provided', async () => {
+            const templateChoice = {
+                name: 'Test Module',
+                value: mockComponentTemplate,
+            };
+            const componentTemplates = [templateChoice];
+            const promptOptions = {
+                features: ['module'],
+            };
+            const result = await selectProjectTemplatePrompt(promptOptions, undefined, componentTemplates);
+            expect(result.componentTemplates).toEqual([mockComponentTemplate]);
+        });
+        it('should prefer cliSelector over type when both are available', async () => {
+            const templateChoice = {
+                name: 'Workflow Action Tool',
+                value: mockComponentTemplateWithCliSelector,
+            };
+            const componentTemplates = [templateChoice];
+            const promptOptions = {
+                features: ['workflow-action-tool'], // matches cliSelector, not type
+            };
+            const result = await selectProjectTemplatePrompt(promptOptions, undefined, componentTemplates);
+            expect(result.componentTemplates).toEqual([
+                mockComponentTemplateWithCliSelector,
+            ]);
+        });
+        it('should not select component when neither cliSelector nor type matches', async () => {
+            const templateChoice = {
+                name: 'Test Module',
+                value: mockComponentTemplate,
+            };
+            const componentTemplates = [templateChoice];
+            const promptOptions = {
+                features: ['non-matching-feature'],
+            };
+            const result = await selectProjectTemplatePrompt(promptOptions, undefined, componentTemplates);
+            expect(result.componentTemplates).toEqual([]);
+        });
+        it('should throw error when selected feature component is disabled', async () => {
+            const disabledTemplateChoice = {
+                name: 'Disabled Component',
+                value: mockComponentTemplateWithCliSelector,
+                disabled: 'Component is disabled for testing',
+            };
+            const componentTemplates = [disabledTemplateChoice];
+            const promptOptions = {
+                features: ['workflow-action-tool'],
+            };
+            await expect(selectProjectTemplatePrompt(promptOptions, undefined, componentTemplates)).rejects.toThrow(/Cannot create project with template.*workflow-action/);
+        });
+        it('should handle multiple components with mixed cliSelector availability', async () => {
+            const choice1 = {
+                name: 'Test Module',
+                value: mockComponentTemplate,
+            };
+            const choice2 = {
+                name: 'Workflow Action Tool',
+                value: mockComponentTemplateWithCliSelector,
+            };
+            const componentTemplates = [choice1, choice2];
+            const promptOptions = {
+                features: ['module', 'workflow-action-tool'],
+            };
+            const result = await selectProjectTemplatePrompt(promptOptions, undefined, componentTemplates);
+            expect(result.componentTemplates).toEqual([
+                mockComponentTemplate,
+                mockComponentTemplateWithCliSelector,
+            ]);
+        });
+        it('should skip Separator instances when processing components', async () => {
+            const separator = new Separator();
+            const templateChoice = {
+                name: 'Test Module',
+                value: mockComponentTemplate,
+            };
+            const componentTemplates = [separator, templateChoice];
+            const promptOptions = {
+                features: ['module'],
+            };
+            const result = await selectProjectTemplatePrompt(promptOptions, undefined, componentTemplates);
+            expect(result.componentTemplates).toEqual([mockComponentTemplate]);
+        });
+        it('should prompt user when no features provided', async () => {
+            const templateChoice = {
+                name: 'Test Module',
+                value: mockComponentTemplate,
+            };
+            const componentTemplates = [templateChoice];
+            const promptOptions = {};
+            mockedPromptUser.mockResolvedValue({
+                componentTemplates: [mockComponentTemplate],
+            });
+            const result = await selectProjectTemplatePrompt(promptOptions, undefined, componentTemplates);
+            expect(mockedPromptUser).toHaveBeenCalledWith([
+                expect.objectContaining({ name: 'projectTemplate' }),
+                expect.objectContaining({
+                    name: 'componentTemplates',
+                    type: 'checkbox',
+                    choices: componentTemplates,
+                }),
+            ]);
+            expect(result.componentTemplates).toEqual([mockComponentTemplate]);
+        });
+        it('should handle empty componentTemplates selection', async () => {
+            const templateChoice = {
+                name: 'Test Module',
+                value: mockComponentTemplate,
+            };
+            const componentTemplates = [templateChoice];
+            const promptOptions = {
+                features: ['non-matching-feature'],
+            };
+            const result = await selectProjectTemplatePrompt(promptOptions, undefined, componentTemplates);
+            expect(result.componentTemplates).toEqual([]);
+        });
+    });
+});

package/lib/prompts/createDeveloperTestAccountConfigPrompt.js

@@ -101,6 +101,7 @@ export async function createDeveloperTestAccountConfigPrompt(args = {}, supportF
             type: 'checkbox',
             pageSize: 13,
             choices: TEST_ACCOUNT_TIERS,
+            loop: false,
             validate: choices => {
                 if (choices?.length < Object.keys(hubs).length) {
                     return lib.prompts.createDeveloperTestAccountConfigPrompt.errors

package/lib/prompts/importDataFilePathPrompt.js

@@ -1,8 +1,8 @@
 import { validateImportRequestFile } from '@hubspot/local-dev-lib/crm';
 import { promptUser } from './promptUtils.js';
 import { lib } from '../../lang/en.js';
-import { logError } from '../errorHandlers/index.js';
 import { uiLogger } from '../ui/logger.js';
+import { isErrorWithMessageOrReason } from '../errorHandlers/index.js';
 export async function importDataFilePathPrompt() {
     uiLogger.log(lib.prompts.importDataFilePathPrompt.promptContext);
     const { filePath } = await promptUser({
@@ -15,7 +15,9 @@ export async function importDataFilePathPrompt() {
                 return true;
             }
             catch (error) {
-                logError(error);
+                if (isErrorWithMessageOrReason(error) && error.message) {
+                    return error.message;
+                }
                 return false;
             }
         },

package/lib/prompts/installAppPrompt.d.ts

@@ -1,2 +1,7 @@
-export declare function installAppBrowserPrompt(installUrl: string, isReinstall?: boolean): Promise<void>;
+export declare function installAppBrowserPrompt(installUrl: string, isReinstall?: boolean, staticAuthInstallOptions?: {
+    testingAccountId: number;
+    projectAccountId: number;
+    projectName: string;
+    appUid: string;
+}): Promise<void>;
 export declare function installAppAutoPrompt(): Promise<boolean>;

package/lib/prompts/installAppPrompt.js

@@ -3,7 +3,7 @@ import { promptUser } from './promptUtils.js';
 import { EXIT_CODES } from '../enums/exitCodes.js';
 import { lib } from '../../lang/en.js';
 import { uiLogger } from '../ui/logger.js';
-export async function installAppBrowserPrompt(installUrl, isReinstall = false) {
+export async function installAppBrowserPrompt(installUrl, isReinstall = false, staticAuthInstallOptions) {
     uiLogger.log('');
     if (isReinstall) {
         uiLogger.log(lib.prompts.installAppPrompt.reinstallExplanation);
@@ -11,6 +11,11 @@ export async function installAppBrowserPrompt(installUrl, isReinstall = false) {
     else {
         uiLogger.log(lib.prompts.installAppPrompt.explanation);
     }
+    if (staticAuthInstallOptions) {
+        const { testingAccountId, projectAccountId, projectName, appUid } = staticAuthInstallOptions;
+        uiLogger.log(lib.prompts.installAppPrompt.staticAuthExplanation(projectAccountId, testingAccountId, projectName, appUid));
+        uiLogger.log('');
+    }
     const { shouldOpenBrowser } = await promptUser({
         name: 'shouldOpenBrowser',
         type: 'confirm',

package/lib/prompts/projectAddPrompt.js

@@ -51,7 +51,7 @@ export async function projectAddPromptV3(components, selectedFeatures) {
             if (template instanceof Separator || !template.value) {
                 return;
             }
-            if (selectedFeatures?.includes(template.value.type)) {
+            if (selectedFeatures?.includes(template.value.cliSelector || template.value.type)) {
                 if (template.disabled) {
                     throw new Error(lib.prompts.projectAddPrompt.errors.cannotAddFeature(template.value.type, template.disabled));
                 }

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/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.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;
+    endpoint: z.ZodString;
+    account: z.ZodOptional<z.ZodString>;
+    latest: z.ZodOptional<z.ZodBoolean>;
+    compact: z.ZodOptional<z.ZodBoolean>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    endpoint: string;
+    absoluteCurrentWorkingDirectory: string;
+    account?: string | undefined;
+    limit?: number | undefined;
+    compact?: boolean | undefined;
+    latest?: boolean | undefined;
+}, {
+    endpoint: string;
+    absoluteCurrentWorkingDirectory: string;
+    account?: string | undefined;
+    limit?: number | undefined;
+    compact?: boolean | undefined;
+    latest?: boolean | undefined;
+}>;
+export type HsFunctionLogsInputSchema = z.infer<typeof inputSchemaZodObject>;
+export declare class HsFunctionLogsTool extends Tool<HsFunctionLogsInputSchema> {
+    constructor(mcpServer: McpServer);
+    handler({ endpoint, account, latest, compact, limit, absoluteCurrentWorkingDirectory, }: HsFunctionLogsInputSchema): Promise<TextContentResponse>;
+    register(): RegisteredTool;
+}
+export {};

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

@@ -0,0 +1,76 @@
+import { Tool } from '../../types.js';
+import { z } from 'zod';
+import { addFlag } from '../../utils/command.js';
+import { absoluteCurrentWorkingDirectory } from '../project/constants.js';
+import { runCommandInDir } from '../../utils/project.js';
+import { formatTextContents } from '../../utils/content.js';
+import { trackToolUsage } from '../../utils/toolUsageTracking.js';
+const inputSchema = {
+    absoluteCurrentWorkingDirectory,
+    endpoint: z
+        .string()
+        .describe('The function endpoint/path to get logs for. Required. Example: "my-function" or "api/my-endpoint" (leading slash will be automatically removed)'),
+    account: z
+        .string()
+        .describe('The HubSpot account id or name from the HubSpot config file to use for the operation.')
+        .optional(),
+    latest: z
+        .boolean()
+        .describe('Get only the latest log entry for the function.')
+        .optional(),
+    compact: z.boolean().describe('Display logs in compact format.').optional(),
+    limit: z
+        .number()
+        .describe('Maximum number of log entries to retrieve.')
+        .optional(),
+};
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const inputSchemaZodObject = z.object({ ...inputSchema });
+const toolName = 'get-cms-serverless-function-logs';
+export class HsFunctionLogsTool extends Tool {
+    constructor(mcpServer) {
+        super(mcpServer);
+    }
+    async handler({ endpoint, account, latest, compact, limit, absoluteCurrentWorkingDirectory, }) {
+        await trackToolUsage(toolName);
+        // Ensure endpoint doesn't start with '/'
+        const normalizedEndpoint = endpoint.startsWith('/')
+            ? endpoint.slice(1)
+            : endpoint;
+        let command = `hs logs ${normalizedEndpoint}`;
+        if (latest) {
+            command = addFlag(command, 'latest', latest);
+        }
+        if (compact) {
+            command = addFlag(command, 'compact', compact);
+        }
+        if (limit) {
+            command = addFlag(command, 'limit', limit);
+        }
+        if (account) {
+            command = addFlag(command, 'account', account);
+        }
+        try {
+            const { stdout, stderr } = await runCommandInDir(absoluteCurrentWorkingDirectory, command);
+            return formatTextContents(stdout, stderr);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error executing hs logs command: ${errorMessage}`,
+                    },
+                ],
+            };
+        }
+    }
+    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-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.d.ts

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