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

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

@@ -0,0 +1,118 @@
+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 { CONTENT_TYPES } from '../../../types/Cms.js';
+const inputSchema = {
+    absoluteCurrentWorkingDirectory,
+    userSuppliedName: z
+        .string()
+        .describe('REQUIRED - If not specified by the user, DO NOT choose. Ask the user to specify the name of the module they want to create.')
+        .optional(),
+    dest: z
+        .string()
+        .describe('The destination path where the module should be created on the current computer.')
+        .optional(),
+    moduleLabel: z
+        .string()
+        .describe('Label for module creation. Required for non-interactive module creation. If not provided, ask the user to provide it.')
+        .optional(),
+    reactType: z
+        .boolean()
+        .describe('Whether to create a React module. If the user has not specified that they want a React module, DO NOT choose for them, ask them what type of module they want to create HubL or React.')
+        .optional(),
+    contentTypes: z
+        .string()
+        .refine(val => {
+        if (!val)
+            return true; // optional
+        const types = val.split(',').map(t => t.trim().toUpperCase());
+        return types.every(type => CONTENT_TYPES.includes(type));
+    }, {
+        message: `Content types must be a comma-separated list of valid values: ${CONTENT_TYPES.join(', ')}`,
+    })
+        .describe(`Content types where the module can be used. Comma-separated list. Valid values: ${CONTENT_TYPES.join(', ')}. Defaults to "ANY".`)
+        .optional(),
+    global: z
+        .boolean()
+        .describe('Whether the module is global. Defaults to false.')
+        .optional(),
+    availableForNewContent: z
+        .boolean()
+        .describe('Whether the module is available for new content. Defaults to true.')
+        .optional(),
+};
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const inputSchemaZodObject = z.object({ ...inputSchema });
+const toolName = 'create-cms-module';
+export class HsCreateModuleTool extends Tool {
+    constructor(mcpServer) {
+        super(mcpServer);
+    }
+    async handler({ userSuppliedName, dest, moduleLabel, reactType, contentTypes, global, availableForNewContent, absoluteCurrentWorkingDirectory, }) {
+        await trackToolUsage(toolName);
+        const content = [];
+        // Always require a name
+        if (!userSuppliedName) {
+            content.push(formatTextContent(`Ask the user to specify the name of the module they want to create.`));
+        }
+        // Require module label
+        if (!moduleLabel) {
+            content.push(formatTextContent(`Ask the user to provide a label for the module.`));
+        }
+        // Ask about React vs HubL if not specified
+        if (reactType === undefined) {
+            content.push(formatTextContent(`Ask the user what type of module they want to create: HubL or React?`));
+        }
+        // If we have missing required information, return the prompts
+        if (content.length > 0) {
+            return {
+                content,
+            };
+        }
+        // Build the command
+        let command = 'hs create module';
+        if (userSuppliedName) {
+            command += ` "${userSuppliedName}"`;
+        }
+        if (dest) {
+            command += ` "${dest}"`;
+        }
+        // Add module-specific flags
+        if (moduleLabel) {
+            command = addFlag(command, 'module-label', moduleLabel);
+        }
+        if (reactType !== undefined) {
+            command = addFlag(command, 'react-type', reactType);
+        }
+        if (contentTypes) {
+            command = addFlag(command, 'content-types', contentTypes);
+        }
+        else {
+            command = addFlag(command, 'content-types', 'ANY');
+        }
+        if (global !== undefined) {
+            command = addFlag(command, 'global', global);
+        }
+        if (availableForNewContent !== undefined) {
+            command = addFlag(command, 'available-for-new-content', availableForNewContent);
+        }
+        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 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,
+        }, this.handler);
+    }
+}

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

@@ -0,0 +1,26 @@
+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>;
+    templateType: z.ZodOptional<z.ZodEnum<["page-template", "email-template", "partial", "global-partial", "blog-listing-template", "blog-post-template", "search-template", "section"]>>;
+}, "strip", z.ZodTypeAny, {
+    absoluteCurrentWorkingDirectory: string;
+    dest?: string | undefined;
+    templateType?: "page-template" | "email-template" | "partial" | "global-partial" | "blog-listing-template" | "blog-post-template" | "search-template" | "section" | undefined;
+    userSuppliedName?: string | undefined;
+}, {
+    absoluteCurrentWorkingDirectory: string;
+    dest?: string | undefined;
+    templateType?: "page-template" | "email-template" | "partial" | "global-partial" | "blog-listing-template" | "blog-post-template" | "search-template" | "section" | undefined;
+    userSuppliedName?: string | undefined;
+}>;
+export type HsCreateTemplateInputSchema = z.infer<typeof inputSchemaZodObject>;
+export declare class HsCreateTemplateTool extends Tool<HsCreateTemplateInputSchema> {
+    constructor(mcpServer: McpServer);
+    handler({ userSuppliedName, dest, templateType, absoluteCurrentWorkingDirectory, }: HsCreateTemplateInputSchema): Promise<TextContentResponse>;
+    register(): RegisteredTool;
+}
+export {};

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

@@ -0,0 +1,75 @@
+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 { TEMPLATE_TYPES } from '../../../types/Cms.js';
+const inputSchema = {
+    absoluteCurrentWorkingDirectory,
+    userSuppliedName: z
+        .string()
+        .describe('REQUIRED - If not specified by the user, DO NOT choose. Ask the user to specify the name of the template they want to create.')
+        .optional(),
+    dest: z
+        .string()
+        .describe('The destination path where the template should be created on the current computer.')
+        .optional(),
+    templateType: z
+        .enum(TEMPLATE_TYPES)
+        .describe(`Template type for template creation. Must be one of: ${TEMPLATE_TYPES.join(', ')}`)
+        .optional(),
+};
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const inputSchemaZodObject = z.object({ ...inputSchema });
+const toolName = 'create-cms-template';
+export class HsCreateTemplateTool extends Tool {
+    constructor(mcpServer) {
+        super(mcpServer);
+    }
+    async handler({ userSuppliedName, dest, templateType, absoluteCurrentWorkingDirectory, }) {
+        await trackToolUsage(toolName);
+        const content = [];
+        // Always require a name
+        if (!userSuppliedName) {
+            content.push(formatTextContent(`Ask the user to specify the name of the template they want to create.`));
+        }
+        // Require template type
+        if (!templateType) {
+            content.push(formatTextContent(`Ask the user what template type they want to create. Options are: ${TEMPLATE_TYPES.join(', ')}`));
+        }
+        // If we have missing required information, return the prompts
+        if (content.length > 0) {
+            return {
+                content,
+            };
+        }
+        // Build the command
+        let command = 'hs create template';
+        if (userSuppliedName) {
+            command += ` "${userSuppliedName}"`;
+        }
+        if (dest) {
+            command += ` "${dest}"`;
+        }
+        // Add template type flag
+        if (templateType) {
+            command = addFlag(command, 'template-type', templateType);
+        }
+        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 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,
+        }, this.handler);
+    }
+}

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

@@ -0,0 +1,23 @@
+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;
+    account: z.ZodOptional<z.ZodString>;
+    json: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    absoluteCurrentWorkingDirectory: string;
+    account?: string | undefined;
+    json?: boolean | undefined;
+}, {
+    absoluteCurrentWorkingDirectory: string;
+    account?: string | undefined;
+    json?: boolean | undefined;
+}>;
+export type HsListFunctionsInputSchema = z.infer<typeof inputSchemaZodObject>;
+export declare class HsListFunctionsTool extends Tool<HsListFunctionsInputSchema> {
+    constructor(mcpServer: McpServer);
+    handler({ account, json, absoluteCurrentWorkingDirectory, }: HsListFunctionsInputSchema): Promise<TextContentResponse>;
+    register(): RegisteredTool;
+}
+export {};

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

@@ -0,0 +1,58 @@
+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,
+    account: z
+        .string()
+        .describe('The HubSpot account id or name from the HubSpot config file to use for the operation.')
+        .optional(),
+    json: z
+        .boolean()
+        .describe('Return raw JSON output instead of formatted table. Useful for programmatic access.')
+        .optional(),
+};
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const inputSchemaZodObject = z.object({ ...inputSchema });
+const toolName = 'list-cms-serverless-functions';
+export class HsListFunctionsTool extends Tool {
+    constructor(mcpServer) {
+        super(mcpServer);
+    }
+    async handler({ account, json, absoluteCurrentWorkingDirectory, }) {
+        await trackToolUsage(toolName);
+        let command = 'hs function list';
+        if (json) {
+            command += ' --json';
+        }
+        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 function list command: ${errorMessage}`,
+                    },
+                ],
+            };
+        }
+    }
+    register() {
+        return this.mcpServer.registerTool(toolName, {
+            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,
+        }, this.handler);
+    }
+}

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

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