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

package/commands/app.js

@@ -1,16 +1,11 @@
 import migrateCommand from './app/migrate.js';
 import appSecretCommand from './app/secret.js';
-import installAppCommand from './app/install.js';
 import { makeYargsBuilder } from '../lib/yargsUtils.js';
 const command = ['app', 'apps'];
 // Keep the command hidden for now
 const describe = undefined;
 function appBuilder(yargs) {
-    yargs
-        .command(migrateCommand)
-        .command(appSecretCommand)
-        .command(installAppCommand)
-        .demandCommand(1, '');
+    yargs.command(migrateCommand).command(appSecretCommand).demandCommand(1, '');
     return yargs;
 }
 const builder = makeYargsBuilder(appBuilder, command, describe);

package/commands/project/upload.d.ts

@@ -1,5 +1,5 @@
-import { CommonArgs, EnvironmentArgs, JSONOutputArgs, YargsCommandModule } from '../../types/Yargs.js';
-type ProjectUploadArgs = CommonArgs & JSONOutputArgs & EnvironmentArgs & {
+import { CommonArgs, JSONOutputArgs, YargsCommandModule } from '../../types/Yargs.js';
+type ProjectUploadArgs = CommonArgs & JSONOutputArgs & {
     forceCreate: boolean;
     message: string;
     m: string;

package/commands/project/upload.js

@@ -25,7 +25,7 @@ async function handler(args) {
     validateProjectConfig(projectConfig, projectDir);
     let targetAccountId;
     if (useV3Api(projectConfig.platformVersion)) {
-        targetAccountId = await loadAndValidateProfile(projectConfig, projectDir, profile, args.useEnv);
+        targetAccountId = await loadAndValidateProfile(projectConfig, projectDir, profile);
     }
     targetAccountId = targetAccountId || derivedAccountId;
     const accountConfig = getAccountConfig(targetAccountId);

package/commands/testAccount/create.js

@@ -75,9 +75,6 @@ async function handler(args) {
         resultJson.personalAccessKey = createResult.personalAccessKey;
     }
     catch (err) {
-        SpinniesManager.fail('createTestAccount', {
-            text: commands.testAccount.create.polling.createFailure,
-        });
         logError(err);
         SpinniesManager.fail('createTestAccount', {
             text: commands.testAccount.create.polling.createFailure,

package/lang/en.d.ts

@@ -1550,28 +1550,6 @@ ${string}`;
     readonly app: {
         readonly describe: "Commands for managing apps.";
         readonly subcommands: {
-            readonly install: {
-                readonly describe: "Install an OAuth app into a test account.";
-                readonly options: {
-                    readonly appUid: "The uid of the app to install";
-                    readonly projectName: "The name of the project that contains the app";
-                };
-                readonly positionals: {
-                    readonly testAccountId: "The id of the test account to install the app into";
-                };
-                readonly errors: {
-                    readonly mustSpecifyProjectName: `You must specify a project name. Use the ${string} flag to specify the project name or run this command from within a project directory.`;
-                    readonly noAppUidFound: `No app uid found. Please specify the app uid with the ${string} flag or run this command from within a project that contains an app.`;
-                    readonly appMustBeOauth: "This command only supports installing oauth apps. Please specify an app with oauth auth type.";
-                };
-                readonly polling: {
-                    readonly start: "Installing app...";
-                    readonly success: "App installed successfully";
-                    readonly failure: "App installation failed";
-                    readonly error: "Error installing app";
-                };
-                readonly example: "Install the app with uid my-app-uid from the project named \"my-project\" into the target account with id 1234567890";
-            };
             readonly secret: {
                 readonly describe: "Commands for managing secrets.";
                 readonly subcommands: {
@@ -3404,7 +3382,7 @@ Run ${string} to upgrade to version ${string}`;
         readonly componentsToBeMigrated: (components: string) => string;
         readonly componentsThatWillNotBeMigrated: (components: string) => string;
         readonly sourceContentsMoved: (newLocation: string) => string;
-        readonly projectMigrationWarningTitle: "⚠️ Important: Migrating to platformVersion 2025.2 is irreversible ⚠️";
+        readonly projectMigrationWarningTitle: "Important: Migrating to platformVersion 2025.2 is irreversible";
         readonly projectMigrationWarning: string;
         readonly success: {
             readonly downloadedProject: (projectName: string, projectDest: string) => string;

package/lang/en.js

@@ -1547,28 +1547,6 @@ export const commands = {
     app: {
         describe: 'Commands for managing apps.',
         subcommands: {
-            install: {
-                describe: 'Install an OAuth app into a test account.',
-                options: {
-                    appUid: 'The uid of the app to install',
-                    projectName: 'The name of the project that contains the app',
-                },
-                positionals: {
-                    testAccountId: 'The id of the test account to install the app into',
-                },
-                errors: {
-                    mustSpecifyProjectName: `You must specify a project name. Use the ${uiCommandReference('--project-name')} flag to specify the project name or run this command from within a project directory.`,
-                    noAppUidFound: `No app uid found. Please specify the app uid with the ${uiCommandReference('--app-uid')} flag or run this command from within a project that contains an app.`,
-                    appMustBeOauth: 'This command only supports installing oauth apps. Please specify an app with oauth auth type.',
-                },
-                polling: {
-                    start: 'Installing app...',
-                    success: 'App installed successfully',
-                    failure: 'App installation failed',
-                    error: 'Error installing app',
-                },
-                example: 'Install the app with uid my-app-uid from the project named "my-project" into the target account with id 1234567890',
-            },
             secret: {
                 describe: 'Commands for managing secrets.',
                 subcommands: {
@@ -3398,7 +3376,7 @@ export const lib = {
         componentsToBeMigrated: (components) => `The following features will be migrated: ${components}`,
         componentsThatWillNotBeMigrated: (components) => `[NOTE] These features are not yet supported for migration but will be available later: ${components}`,
         sourceContentsMoved: (newLocation) => `The contents of your old source directory have been moved to ${newLocation}, move any required files to the new source directory.`,
-        projectMigrationWarningTitle: '⚠️ Important: Migrating to platformVersion 2025.2 is irreversible ⚠️',
+        projectMigrationWarningTitle: 'Important: Migrating to platformVersion 2025.2 is irreversible',
         projectMigrationWarning: uiBetaTag(`Running the ${uiCommandReference('hs project migrate')} command will permanently upgrade your project to platformVersion 2025.2. This action cannot be undone. To ensure you have access to your original files, they will be copied to a new directory (archive) for safekeeping.\n\nThis command will guide you through the process, prompting you to enter the required fields and will download the new project source code into your project source directory.`, false),
         success: {
             downloadedProject: (projectName, projectDest) => `Saved ${projectName} to ${projectDest}`,

package/lib/mcp/setup.js

@@ -182,7 +182,7 @@ export async function setupClaudeCode(mcpCommand = defaultMcpCommand) {
                 });
                 await execAsync(`claude mcp remove "${mcpServerName}" --scope user`);
             }
-            await execAsync(`claude mcp add-json "${mcpServerName}" '${mcpConfig}' --scope user`);
+            await execAsync(`claude mcp add-json "${mcpServerName}" ${JSON.stringify(mcpConfig)} --scope user`);
             SpinniesManager.succeed('claudeCode', {
                 text: commands.mcp.setup.spinners.configuredClaudeCode,
             });

package/lib/projectProfiles.d.ts

@@ -4,4 +4,4 @@ export declare function logProfileHeader(profileName: string): void;
 export declare function logProfileFooter(profile: HsProfileFile, includeVariables?: boolean): void;
 export declare function loadProfile(projectConfig: ProjectConfig | null, projectDir: string | null, profileName: string): HsProfileFile | undefined;
 export declare function exitIfUsingProfiles(projectConfig: ProjectConfig | null, projectDir: string | null): Promise<void>;
-export declare function loadAndValidateProfile(projectConfig: ProjectConfig | null, projectDir: string | null, argsProfile: string | undefined, useEnv?: boolean): Promise<number | undefined>;
+export declare function loadAndValidateProfile(projectConfig: ProjectConfig | null, projectDir: string | null, argsProfile: string | undefined): Promise<number | undefined>;

package/lib/projectProfiles.js

@@ -38,12 +38,7 @@ export function loadProfile(projectConfig, projectDir, profileName) {
             uiLogger.error(lib.projectProfiles.loadProfile.errors.missingAccountId(profileFilename));
             return;
         }
-        return {
-            ...profile,
-            accountId: process.env.HUBSPOT_ACCOUNT_ID
-                ? Number(process.env.HUBSPOT_ACCOUNT_ID)
-                : profile.accountId,
-        };
+        return profile;
     }
     catch (e) {
         uiLogger.error(lib.projectProfiles.loadProfile.errors.failedToLoadProfile(profileFilename));
@@ -59,7 +54,7 @@ export async function exitIfUsingProfiles(projectConfig, projectDir) {
         }
     }
 }
-export async function loadAndValidateProfile(projectConfig, projectDir, argsProfile, useEnv = false) {
+export async function loadAndValidateProfile(projectConfig, projectDir, argsProfile) {
     if (argsProfile) {
         logProfileHeader(argsProfile);
         const profile = loadProfile(projectConfig, projectDir, argsProfile);
@@ -68,9 +63,6 @@ export async function loadAndValidateProfile(projectConfig, projectDir, argsProf
             process.exit(EXIT_CODES.ERROR);
         }
         logProfileFooter(profile, true);
-        if (useEnv) {
-            return Number(process.env.HUBSPOT_ACCOUNT_ID);
-        }
         return profile.accountId;
     }
     else {

package/lib/projects/structure.d.ts

@@ -1,5 +1,5 @@
 import { ComponentTypes, Component, GenericComponentConfig, PublicAppComponentConfig, PrivateAppComponentConfig, AppCardComponentConfig } from '../../types/Projects.js';
-import { IntermediateRepresentationNode, IntermediateRepresentationNodeLocalDev } from '@hubspot/project-parsing-lib/src/lib/types.js';
+import { IntermediateRepresentationNodeLocalDev } from '@hubspot/project-parsing-lib/src/lib/types.js';
 import { AppIRNode } from '../../types/ProjectComponents.js';
 export declare const CONFIG_FILES: {
     [k in ComponentTypes]: string;
@@ -15,4 +15,4 @@ export declare function getProjectComponentTypes(components: Array<Component>):
 export declare function getComponentUid(component?: Component | null): string | null;
 export declare function componentIsApp(component?: Component | null): component is Component<PublicAppComponentConfig | PrivateAppComponentConfig>;
 export declare function componentIsPublicApp(component?: Component | null): component is Component<PublicAppComponentConfig>;
-export declare function isAppIRNode(component: IntermediateRepresentationNodeLocalDev | IntermediateRepresentationNode): component is AppIRNode;
+export declare function isAppIRNode(component: IntermediateRepresentationNodeLocalDev): component is AppIRNode;

package/lib/projects/upload.d.ts

@@ -1,5 +1,4 @@
 import { FileResult } from 'tmp';
-import { IntermediateRepresentation } from '@hubspot/project-parsing-lib';
 import { ProjectConfig } from '../../types/Projects.js';
 type ProjectUploadCallbackFunction<T> = (accountId: number, projectConfig: ProjectConfig, tempFile: FileResult, buildId: number) => Promise<T>;
 type ProjectUploadResult<T> = {
@@ -21,5 +20,5 @@ type HandleProjectUploadArg<T> = {
 export declare function handleProjectUpload<T>({ accountId, projectConfig, projectDir, callbackFunc, profile, uploadMessage, forceCreate, isUploadCommand, sendIR, skipValidation, }: HandleProjectUploadArg<T>): Promise<ProjectUploadResult<T>>;
 export declare function validateSourceDirectory(srcDir: string, projectConfig: ProjectConfig): void;
 export declare function validateNoHSMetaMismatch(srcDir: string, projectConfig: ProjectConfig): Promise<void>;
-export declare function handleTranslate(projectDir: string, projectConfig: ProjectConfig, accountId: number, skipValidation: boolean, profile: string | undefined): Promise<IntermediateRepresentation | undefined>;
+export declare function handleTranslate(projectDir: string, projectConfig: ProjectConfig, accountId: number, skipValidation: boolean, profile: string | undefined): Promise<unknown>;
 export {};

package/lib/projects/upload.js

@@ -133,5 +133,4 @@ export async function handleTranslate(projectDir, projectConfig, accountId, skip
         }
         throw e;
     }
-    return undefined;
 }

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