@hubspot/cli 8.0.10-experimental.6 → 8.0.11-experimental.0

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

@@ -0,0 +1,24 @@
+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<{
+        GET: "GET";
+        DELETE: "DELETE";
+        POST: "POST";
+        PUT: "PUT";
+        PATCH: "PATCH";
+    }>>;
+    endpointPath: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+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,105 @@
+import { Tool } from '../../types.js';
+import { z } from 'zod';
+import { absoluteCurrentWorkingDirectory } from '../project/constants.js';
+import { runCommandInDir } from '../../utils/command.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';
+import { setupHubSpotConfig } from '../../utils/config.js';
+import { getErrorMessage } from '../../../lib/errorHandlers/index.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, }) {
+        setupHubSpotConfig(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(getErrorMessage(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,
+            annotations: {
+                readOnlyHint: false,
+                destructiveHint: false,
+                idempotentHint: false,
+                openWorldHint: false,
+            },
+        }, this.handler);
+    }
+}

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

@@ -0,0 +1,20 @@
+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.ZodString>;
+    global: z.ZodOptional<z.ZodBoolean>;
+    availableForNewContent: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+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,127 @@
+import { Tool } from '../../types.js';
+import { z } from 'zod';
+import { absoluteCurrentWorkingDirectory } from '../project/constants.js';
+import { runCommandInDir } from '../../utils/command.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';
+import { setupHubSpotConfig } from '../../utils/config.js';
+import { getErrorMessage } from '../../../lib/errorHandlers/index.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, }) {
+        setupHubSpotConfig(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(getErrorMessage(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,
+            annotations: {
+                readOnlyHint: false,
+                destructiveHint: false,
+                idempotentHint: false,
+                openWorldHint: false,
+            },
+        }, this.handler);
+    }
+}

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

@@ -0,0 +1,25 @@
+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<{
+        section: "section";
+        "page-template": "page-template";
+        "email-template": "email-template";
+        partial: "partial";
+        "global-partial": "global-partial";
+        "blog-listing-template": "blog-listing-template";
+        "blog-post-template": "blog-post-template";
+        "search-template": "search-template";
+    }>>;
+}, z.core.$strip>;
+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,84 @@
+import { Tool } from '../../types.js';
+import { z } from 'zod';
+import { absoluteCurrentWorkingDirectory } from '../project/constants.js';
+import { runCommandInDir } from '../../utils/command.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';
+import { setupHubSpotConfig } from '../../utils/config.js';
+import { getErrorMessage } from '../../../lib/errorHandlers/index.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, }) {
+        setupHubSpotConfig(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(getErrorMessage(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,
+            annotations: {
+                readOnlyHint: false,
+                destructiveHint: false,
+                idempotentHint: false,
+                openWorldHint: false,
+            },
+        }, this.handler);
+    }
+}

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

@@ -0,0 +1,18 @@
+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>;
+}, z.core.$strip>;
+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,75 @@
+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/command.js';
+import { formatTextContents } from '../../utils/content.js';
+import { trackToolUsage } from '../../utils/toolUsageTracking.js';
+import { setupHubSpotConfig } from '../../utils/config.js';
+import { getErrorMessage } from '../../../lib/errorHandlers/index.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, }) {
+        setupHubSpotConfig(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) {
+            return formatTextContents(`Error executing hs logs command: ${getErrorMessage(error)}`);
+        }
+    }
+    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,
+            annotations: {
+                readOnlyHint: true,
+                openWorldHint: true,
+            },
+        }, this.handler);
+    }
+}

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

@@ -0,0 +1,15 @@
+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>;
+}, z.core.$strip>;
+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,64 @@
+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/command.js';
+import { formatTextContents } from '../../utils/content.js';
+import { trackToolUsage } from '../../utils/toolUsageTracking.js';
+import { setupHubSpotConfig } from '../../utils/config.js';
+import { getErrorMessage } from '../../../lib/errorHandlers/index.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, }) {
+        setupHubSpotConfig(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) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error executing hs function list command: ${getErrorMessage(error)}`,
+                    },
+                ],
+            };
+        }
+    }
+    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,
+            annotations: {
+                readOnlyHint: true,
+                openWorldHint: true,
+            },
+        }, this.handler);
+    }
+}

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

@@ -0,0 +1,15 @@
+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;
+    path: z.ZodOptional<z.ZodString>;
+    account: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type HsListInputSchema = z.infer<typeof inputSchemaZodObject>;
+export declare class HsListTool extends Tool<HsListInputSchema> {
+    constructor(mcpServer: McpServer);
+    handler({ path, account, absoluteCurrentWorkingDirectory, }: HsListInputSchema): Promise<TextContentResponse>;
+    register(): RegisteredTool;
+}
+export {};

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

@@ -0,0 +1,64 @@
+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/command.js';
+import { formatTextContents } from '../../utils/content.js';
+import { trackToolUsage } from '../../utils/toolUsageTracking.js';
+import { setupHubSpotConfig } from '../../utils/config.js';
+import { getErrorMessage } from '../../../lib/errorHandlers/index.js';
+const inputSchema = {
+    absoluteCurrentWorkingDirectory,
+    path: z
+        .string()
+        .describe('The remote directory path in the HubSpot CMS to list contents. If not specified, lists the root directory.')
+        .optional(),
+    account: z
+        .string()
+        .describe('The HubSpot account id or name from the HubSpot config file to use for the operation.')
+        .optional(),
+};
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const inputSchemaZodObject = z.object({ ...inputSchema });
+const toolName = 'list-cms-remote-contents';
+export class HsListTool extends Tool {
+    constructor(mcpServer) {
+        super(mcpServer);
+    }
+    async handler({ path, account, absoluteCurrentWorkingDirectory, }) {
+        setupHubSpotConfig(absoluteCurrentWorkingDirectory);
+        await trackToolUsage(toolName);
+        let command = 'hs list';
+        if (path) {
+            command += ` ${path}`;
+        }
+        if (account) {
+            command = addFlag(command, 'account', account);
+        }
+        try {
+            const { stdout, stderr } = await runCommandInDir(absoluteCurrentWorkingDirectory, command);
+            return formatTextContents(stdout, stderr);
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error executing hs list command: ${getErrorMessage(error)}`,
+                    },
+                ],
+            };
+        }
+    }
+    register() {
+        return this.mcpServer.registerTool(toolName, {
+            title: 'List HubSpot CMS Directory Contents',
+            description: 'List remote contents of a HubSpot CMS directory.',
+            inputSchema,
+            annotations: {
+                readOnlyHint: true,
+                openWorldHint: true,
+            },
+        }, this.handler);
+    }
+}

package/mcp-server/tools/cms/__tests__/HsCreateFunctionTool.test.d.ts

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