@hubspot/cli 7.7.0-experimental.2 → 7.7.0

package/lib/yargsUtils.js

@@ -1,46 +1,49 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasFlag = hasFlag;
-exports.makeYargsBuilder = makeYargsBuilder;
-const process_1 = __importDefault(require("process"));
-const commonOpts_1 = require("./commonOpts");
-// See https://github.com/sindresorhus/has-flag/blob/main/index.js (License: https://github.com/sindresorhus/has-flag/blob/main/license)
-function hasFlag(flag, argv = process_1.default.argv) {
-    const prefix = flag.startsWith('-') ? '' : flag.length === 1 ? '-' : '--';
-    const position = argv.indexOf(prefix + flag);
-    const terminatorPosition = argv.indexOf('--');
-    return (position !== -1 &&
-        (terminatorPosition === -1 || position < terminatorPosition));
-}
-function makeYargsBuilder(callback, command, describe, options = {}) {
+import { addCustomHelpOutput, addTestingOptions, addAccountOptions, addConfigOptions, addGlobalOptions, addUseEnvironmentOptions, addCmsPublishModeOptions, addJSONOutputOptions, } from './commonOpts.js';
+import { hasFlag } from './utils/hasFlag.js';
+import { commands } from '../lang/en.js';
+// Re-export for backwards compatibility
+export { hasFlag };
+export function makeYargsBuilder(callback, command, describe, options = {}) {
     return async function (yargs) {
         if (options.useGlobalOptions) {
-            (0, commonOpts_1.addGlobalOptions)(yargs);
+            addGlobalOptions(yargs);
         }
         if (options.useAccountOptions) {
-            (0, commonOpts_1.addAccountOptions)(yargs);
+            addAccountOptions(yargs);
         }
         if (options.useConfigOptions) {
-            (0, commonOpts_1.addConfigOptions)(yargs);
+            addConfigOptions(yargs);
         }
         if (options.useEnvironmentOptions) {
-            (0, commonOpts_1.addUseEnvironmentOptions)(yargs);
+            addUseEnvironmentOptions(yargs);
         }
         if (options.useTestingOptions) {
-            (0, commonOpts_1.addTestingOptions)(yargs);
+            addTestingOptions(yargs);
+        }
+        if (options.useJSONOutputOptions) {
+            addJSONOutputOptions(yargs);
         }
         if (options.useCmsPublishModeOptions) {
             const opts = typeof options.useCmsPublishModeOptions === 'object'
                 ? options.useCmsPublishModeOptions
                 : { write: true };
-            (0, commonOpts_1.addCmsPublishModeOptions)(yargs, opts);
+            addCmsPublishModeOptions(yargs, opts);
         }
         const result = callback(yargs);
         // Must go last to pick up available options
-        await (0, commonOpts_1.addCustomHelpOutput)(result, command, describe);
+        await addCustomHelpOutput(result, command, describe);
         return result;
     };
 }
+export function strictEnforceBoolean(rawArgs, booleanOptions) {
+    for (const option of booleanOptions) {
+        const argIndex = rawArgs.findIndex(arg => arg.startsWith(`--${option}=`));
+        if (argIndex !== -1) {
+            const value = rawArgs[argIndex].split('=')[1];
+            if (value && !['true', 'false'].includes(value.toLowerCase())) {
+                throw new Error(commands.config.subcommands.set.errors.invalidBoolean(option, value));
+            }
+        }
+    }
+    return true;
+}

package/mcp-server/server.d.ts

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

package/mcp-server/server.js

@@ -0,0 +1,17 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { registerProjectTools, registerCmsTools } from './tools/index.js';
+const server = new McpServer({
+    name: 'HubSpot CLI MCP Server',
+    version: '0.0.1',
+    description: 'Helps perform tasks for local development of HubSpot projects.',
+    capabilities: {
+        tools: {},
+        prompts: {},
+    },
+});
+registerProjectTools(server);
+registerCmsTools(server);
+// Start receiving messages on stdin and sending messages on stdout
+const transport = new StdioServerTransport();
+server.connect(transport);

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 {};

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 {};