@hubspot/cli 7.7.31-experimental.0 → 7.7.33-experimental.0

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.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-hubspot-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/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-hubspot-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-hubspot-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-hubspot-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-hubspot-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);
+    }
+}