@hubspot/cli 8.2.0 → 8.2.1-experimental.0

package/lib/yargs/parseYargsOrExit.js

@@ -0,0 +1,25 @@
+function getYargsErrorMessage(error) {
+    return error instanceof Error && error.name === 'YError' ? error.message : '';
+}
+function getYargsFailureMessage(message, error) {
+    if (message) {
+        return message;
+    }
+    return getYargsErrorMessage(error) || message;
+}
+export async function parseYargsOrExit(parser, handleFailure) {
+    let failureHandled = false;
+    const parserWithFailureHandler = parser.fail((message, error, yargs) => {
+        failureHandled = true;
+        return handleFailure(getYargsFailureMessage(message, error), error, yargs);
+    });
+    try {
+        return await parserWithFailureHandler.parseAsync();
+    }
+    catch (error) {
+        if (failureHandled) {
+            throw error;
+        }
+        return handleFailure(getYargsErrorMessage(error), error, parserWithFailureHandler);
+    }
+}

package/lib/yargs/strictEnforceBoolean.d.ts

@@ -0,0 +1 @@
+export declare function strictEnforceBoolean(rawArgs: string[], booleanOptions: string[]): boolean;

package/lib/yargs/strictEnforceBoolean.js

@@ -0,0 +1,13 @@
+import { commands } from '../../lang/en.js';
+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/lib/yargsUtils.d.ts

@@ -1,16 +1,3 @@
-import { Argv } from 'yargs';
-import { hasFlag } from './utils/hasFlag.js';
-export { hasFlag };
-export declare function makeYargsBuilder<T>(callback: (yargs: Argv) => Argv<T>, command: string | string[], describe?: string, options?: {
-    useGlobalOptions?: boolean;
-    useAccountOptions?: boolean;
-    useConfigOptions?: boolean;
-    useEnvironmentOptions?: boolean;
-    useTestingOptions?: boolean;
-    useCmsPublishModeOptions?: boolean | {
-        read?: boolean;
-        write?: boolean;
-    };
-    useJSONOutputOptions?: boolean;
-}): (yargs: Argv) => Promise<Argv<T>>;
-export declare function strictEnforceBoolean(rawArgs: string[], booleanOptions: string[]): boolean;
+export { hasFlag } from './utils/hasFlag.js';
+export { makeYargsBuilder } from './yargs/makeYargsBuilder.js';
+export { strictEnforceBoolean } from './yargs/strictEnforceBoolean.js';

package/lib/yargsUtils.js

@@ -1,49 +1,4 @@
-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) {
-            addGlobalOptions(yargs);
-        }
-        if (options.useAccountOptions) {
-            addAccountOptions(yargs);
-        }
-        if (options.useConfigOptions) {
-            addConfigOptions(yargs);
-        }
-        if (options.useEnvironmentOptions) {
-            addUseEnvironmentOptions(yargs);
-        }
-        if (options.useTestingOptions) {
-            addTestingOptions(yargs);
-        }
-        if (options.useJSONOutputOptions) {
-            addJSONOutputOptions(yargs);
-        }
-        if (options.useCmsPublishModeOptions) {
-            const opts = typeof options.useCmsPublishModeOptions === 'object'
-                ? options.useCmsPublishModeOptions
-                : { write: true };
-            addCmsPublishModeOptions(yargs, opts);
-        }
-        const result = callback(yargs);
-        // Must go last to pick up available options
-        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;
-}
+export { hasFlag } from './utils/hasFlag.js';
+export { makeYargsBuilder } from './yargs/makeYargsBuilder.js';
+export { strictEnforceBoolean } from './yargs/strictEnforceBoolean.js';

package/mcp-server/Tool.d.ts

@@ -0,0 +1,20 @@
+import { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { RequestHandlerExtra } from '@modelcontextprotocol/sdk/shared/protocol.js';
+import { ServerNotification, ServerRequest } from '@modelcontextprotocol/sdk/types.js';
+import { McpLogger } from './utils/logger.js';
+import { TextContentResponse } from './types.js';
+import { CommandResults, Command } from './utils/command.js';
+export type ToolExtra = RequestHandlerExtra<ServerRequest, ServerNotification>;
+export declare class Tool<InputSchema> {
+    protected mcpServer: McpServer;
+    protected logger: McpLogger;
+    protected toolName: string;
+    constructor(mcpServer: McpServer, logger: McpLogger, toolName: string);
+    register(): RegisteredTool;
+    handler(_input: InputSchema): TextContentResponse | Promise<TextContentResponse>;
+    protected runCommand(directory: string, command: Command, extra?: ToolExtra): Promise<CommandResults>;
+    protected getTrackingMeta(_input: InputSchema): {
+        [key: string]: string;
+    } | undefined;
+    protected wrappedHandler(input: InputSchema, extra?: ToolExtra): Promise<TextContentResponse>;
+}

package/mcp-server/Tool.js

@@ -0,0 +1,79 @@
+import { formatTextContents } from './utils/content.js';
+import { getErrorMessage } from '../lib/errorHandlers/index.js';
+import { trackToolUsage } from './utils/toolUsageTracking.js';
+import { runCommandInDir } from './utils/command.js';
+export class Tool {
+    mcpServer;
+    logger;
+    toolName;
+    constructor(mcpServer, logger, toolName) {
+        this.mcpServer = mcpServer;
+        this.logger = logger;
+        this.toolName = toolName;
+    }
+    register() {
+        throw new Error('Must implement register');
+    }
+    handler(_input) {
+        throw new Error('Must implement handler');
+    }
+    runCommand(directory, command, extra) {
+        let progressCount = 0;
+        return runCommandInDir(directory, command, async (chunk) => {
+            try {
+                const message = `${chunk.trimEnd()}`;
+                this.logger.debug(this.toolName, message);
+                const token = extra?._meta?.progressToken;
+                if (token !== undefined && extra?.sendNotification) {
+                    progressCount++;
+                    await extra.sendNotification({
+                        method: 'notifications/progress',
+                        params: {
+                            progressToken: token,
+                            progress: progressCount,
+                            message,
+                        },
+                    });
+                }
+            }
+            catch {
+                // Swallow notification errors so a failed notification never crashes the tool
+            }
+        });
+    }
+    getTrackingMeta(_input) {
+        return undefined;
+    }
+    wrappedHandler(input, extra) {
+        return this.logger.runWithBuffer(async () => {
+            const startTime = Date.now();
+            try {
+                // `input` is logged unredacted. Tool input schemas MUST NOT include
+                // credentials or other sensitive values, since MCP clients (Claude
+                // Desktop, Inspector, etc.) will display these logs.
+                this.logger.debug(this.toolName, {
+                    message: 'Tool invoked',
+                    args: input,
+                });
+                await trackToolUsage(this.toolName, this.getTrackingMeta(input));
+                const result = await this.handler(input, extra);
+                this.logger.debug(this.toolName, {
+                    message: 'Tool completed',
+                    durationMs: Date.now() - startTime,
+                });
+                return result;
+            }
+            catch (error) {
+                this.logger.error(this.toolName, {
+                    message: 'Tool failed',
+                    error: error instanceof Error ? error.message : String(error),
+                    durationMs: Date.now() - startTime,
+                });
+                return formatTextContents(getErrorMessage(error));
+            }
+            finally {
+                this.logger.flushLogsToFile(this.toolName);
+            }
+        });
+    }
+}

package/mcp-server/server.js

@@ -1,13 +1,57 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { registerProjectTools, registerCmsTools } from './tools/index.js';
+import { McpLogger } from './utils/logger.js';
+const instructions = `
+This server exposes the HubSpot CLI (\`hs\`) for local development of HubSpot
+projects, apps, and CMS assets. Prefer these tools over running \`hs\`,
+\`npx hs\`, or HubSpot HTTP APIs directly via shell — they handle config
+loading, auth, platform-version flags, and structured output for you.
+
+WHEN TO USE THIS SERVER
+- The user is working in a HubSpot project directory (has an hsproject.json
+  or *-hsmeta.json files), or wants to scaffold one.
+- The user asks about HubSpot apps, CMS modules/templates/serverless
+  functions, project builds, deploys, or developer test accounts.
+- The user asks a HubSpot platform/API question — answer it from the docs
+  via \`search-docs\` + \`fetch-doc\` rather than from prior knowledge.
+
+REQUIRED WORKFLOWS
+1. Authentication: call \`auth-account\` when the user wants to connect a
+   HubSpot account, when any tool reports "No account ID found", or when
+   there are no authenticated accounts. The tool opens a browser tab for
+   the user to authorize — no Personal Access Key is required up front.
+2. Documentation lookup: always call \`search-docs\` first, then
+   \`fetch-doc\` on the most relevant result(s) before planning, writing
+   code, or answering platform/API questions. Do not answer from memory.
+3. Locating a HubSpot project: when the current working directory is not
+   a HubSpot project (no \`hsproject.json\`) or you need to determine
+   whether a directory contains one, call \`find-projects\` before
+   running any tool that requires a project path.
+4. Editing \`*-hsmeta.json\`: call \`get-feature-config-schema\` for that
+   feature type first to learn the allowed fields and values.
+5. Debugging a failed build: start with \`get-build-status\` to surface
+   error messages, and only reach for \`get-build-logs\` for deeper
+   troubleshooting or warnings.
+6. Reading serverless function logs: call \`list-cms-serverless-functions\`
+   first to discover the endpoint path, then
+   \`get-cms-serverless-function-logs\`.
+7. App analytics: call \`get-apps-info\` to discover \`appId\` values
+   before \`get-api-usage-patterns-by-app-id\`.
+
+OUTPUT
+Tool results contain the relevant \`hs\` stdout/stderr or structured data.
+Surface error text from results to the user verbatim when troubleshooting,
+rather than paraphrasing.
+`.trim();
 const server = new McpServer({
     name: 'HubSpot CLI MCP Server',
     version: '0.0.1',
     description: 'Helps perform tasks for local development of HubSpot projects.',
-});
-registerProjectTools(server);
-registerCmsTools(server);
+}, { capabilities: { logging: {} }, instructions });
+const logger = new McpLogger(server);
+registerProjectTools(server, logger);
+registerCmsTools(server, logger);
 // 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

@@ -1,5 +1,7 @@
-import { TextContentResponse, Tool } from '../../types.js';
+import { TextContentResponse } from '../../types.js';
+import { Tool, ToolExtra } from '../../Tool.js';
 import { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { McpLogger } from '../../utils/logger.js';
 import { z } from 'zod';
 declare const inputSchemaZodObject: z.ZodObject<{
     absoluteCurrentWorkingDirectory: z.ZodString;
@@ -17,8 +19,8 @@ declare const inputSchemaZodObject: z.ZodObject<{
 }, 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>;
+    constructor(mcpServer: McpServer, logger: McpLogger);
+    handler({ dest, functionsFolder, filename, endpointMethod, endpointPath, absoluteCurrentWorkingDirectory, }: HsCreateFunctionInputSchema, extra?: ToolExtra): Promise<TextContentResponse>;
     register(): RegisteredTool;
 }
 export {};

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

@@ -1,11 +1,9 @@
-import { Tool } from '../../types.js';
+import { Tool } from '../../Tool.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 { HubSpotCommand } from '../../utils/command.js';
 import { setupHubSpotConfig } from '../../utils/config.js';
 import { getErrorMessage } from '../../../lib/errorHandlers/index.js';
 const inputSchema = {
@@ -35,12 +33,11 @@ const inputSchema = {
 const inputSchemaZodObject = z.object({ ...inputSchema });
 const toolName = 'create-cms-function';
 export class HsCreateFunctionTool extends Tool {
-    constructor(mcpServer) {
-        super(mcpServer);
+    constructor(mcpServer, logger) {
+        super(mcpServer, logger, toolName);
     }
-    async handler({ dest, functionsFolder, filename, endpointMethod, endpointPath, absoluteCurrentWorkingDirectory, }) {
+    async handler({ dest, functionsFolder, filename, endpointMethod, endpointPath, absoluteCurrentWorkingDirectory, }, extra) {
         setupHubSpotConfig(absoluteCurrentWorkingDirectory);
-        await trackToolUsage(toolName);
         const content = [];
         // Require functions folder
         if (!functionsFolder) {
@@ -61,38 +58,36 @@ export class HsCreateFunctionTool extends Tool {
             };
         }
         // Build the command
-        let command = 'hs create function';
+        const command = new HubSpotCommand('cms function create');
         if (dest) {
-            command += ` "${dest}"`;
+            command.addArg(dest);
         }
-        // Add function-specific flags
         if (functionsFolder) {
-            command = addFlag(command, 'functions-folder', functionsFolder);
+            command.addFlag('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');
+            command.addFlag('filename', filename);
         }
+        command.addFlag('endpoint-method', endpointMethod ?? 'GET');
         if (endpointPath) {
-            command = addFlag(command, 'endpoint-path', endpointPath);
+            command.addFlag('endpoint-path', endpointPath);
         }
         try {
-            const { stdout, stderr } = await runCommandInDir(absoluteCurrentWorkingDirectory, command);
+            const { stdout, stderr } = await this.runCommand(absoluteCurrentWorkingDirectory, command, extra);
             return formatTextContents(stdout, stderr);
         }
         catch (error) {
+            this.logger.debug(toolName, {
+                message: 'Handler caught error',
+                error: error instanceof Error ? error.message : String(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(', ')}).`,
+            description: `Creates a new HubSpot CMS serverless function using the hs cms function create command. Functions can be created non-interactively by specifying functionsFolder, filename, and endpointPath. Supports all HTTP methods (${HTTP_METHODS.join(', ')}).`,
             inputSchema,
             annotations: {
                 readOnlyHint: false,
@@ -100,6 +95,6 @@ export class HsCreateFunctionTool extends Tool {
                 idempotentHint: false,
                 openWorldHint: false,
             },
-        }, this.handler);
+        }, (input, extra) => this.wrappedHandler(input, extra));
     }
 }

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

@@ -1,5 +1,7 @@
-import { TextContentResponse, Tool } from '../../types.js';
+import { TextContentResponse } from '../../types.js';
+import { Tool, ToolExtra } from '../../Tool.js';
 import { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { McpLogger } from '../../utils/logger.js';
 import { z } from 'zod';
 declare const inputSchemaZodObject: z.ZodObject<{
     absoluteCurrentWorkingDirectory: z.ZodString;
@@ -13,8 +15,8 @@ declare const inputSchemaZodObject: z.ZodObject<{
 }, 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>;
+    constructor(mcpServer: McpServer, logger: McpLogger);
+    handler({ userSuppliedName, dest, moduleLabel, reactType, contentTypes, global, availableForNewContent, absoluteCurrentWorkingDirectory, }: HsCreateModuleInputSchema, extra?: ToolExtra): Promise<TextContentResponse>;
     register(): RegisteredTool;
 }
 export {};

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

@@ -1,11 +1,9 @@
-import { Tool } from '../../types.js';
+import { Tool } from '../../Tool.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 { formatTextContent, formatTextContents } from '../../utils/content.js';
 import { CONTENT_TYPES } from '../../../types/Cms.js';
+import { HubSpotCommand } from '../../utils/command.js';
 import { setupHubSpotConfig } from '../../utils/config.js';
 import { getErrorMessage } from '../../../lib/errorHandlers/index.js';
 const inputSchema = {
@@ -51,12 +49,11 @@ const inputSchema = {
 const inputSchemaZodObject = z.object({ ...inputSchema });
 const toolName = 'create-cms-module';
 export class HsCreateModuleTool extends Tool {
-    constructor(mcpServer) {
-        super(mcpServer);
+    constructor(mcpServer, logger) {
+        super(mcpServer, logger, toolName);
     }
-    async handler({ userSuppliedName, dest, moduleLabel, reactType, contentTypes, global, availableForNewContent, absoluteCurrentWorkingDirectory, }) {
+    async handler({ userSuppliedName, dest, moduleLabel, reactType, contentTypes, global, availableForNewContent, absoluteCurrentWorkingDirectory, }, extra) {
         setupHubSpotConfig(absoluteCurrentWorkingDirectory);
-        await trackToolUsage(toolName);
         const content = [];
         // Always require a name
         if (!userSuppliedName) {
@@ -77,44 +74,42 @@ export class HsCreateModuleTool extends Tool {
             };
         }
         // Build the command
-        let command = 'hs create module';
+        const command = new HubSpotCommand('cms module create');
         if (userSuppliedName) {
-            command += ` "${userSuppliedName}"`;
+            command.addArg(userSuppliedName);
         }
         if (dest) {
-            command += ` "${dest}"`;
+            command.addArg(dest);
         }
-        // Add module-specific flags
         if (moduleLabel) {
-            command = addFlag(command, 'module-label', moduleLabel);
+            command.addFlag('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');
+            command.addFlag('react-type', reactType);
         }
+        command.addFlag('content-types', contentTypes ?? 'ANY');
         if (global !== undefined) {
-            command = addFlag(command, 'global', global);
+            command.addFlag('global', global);
         }
         if (availableForNewContent !== undefined) {
-            command = addFlag(command, 'available-for-new-content', availableForNewContent);
+            command.addFlag('available-for-new-content', availableForNewContent);
         }
         try {
-            const { stdout, stderr } = await runCommandInDir(absoluteCurrentWorkingDirectory, command);
+            const { stdout, stderr } = await this.runCommand(absoluteCurrentWorkingDirectory, command, extra);
             return formatTextContents(stdout, stderr);
         }
         catch (error) {
+            this.logger.debug(toolName, {
+                message: 'Handler caught error',
+                error: error instanceof Error ? error.message : String(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.',
+            description: 'Creates a new HubSpot CMS module using the hs cms module create 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,
@@ -122,6 +117,6 @@ export class HsCreateModuleTool extends Tool {
                 idempotentHint: false,
                 openWorldHint: false,
             },
-        }, this.handler);
+        }, (input, extra) => this.wrappedHandler(input, extra));
     }
 }

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

@@ -1,5 +1,7 @@
-import { TextContentResponse, Tool } from '../../types.js';
+import { TextContentResponse } from '../../types.js';
+import { Tool, ToolExtra } from '../../Tool.js';
 import { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { McpLogger } from '../../utils/logger.js';
 import { z } from 'zod';
 declare const inputSchemaZodObject: z.ZodObject<{
     absoluteCurrentWorkingDirectory: z.ZodString;
@@ -18,8 +20,8 @@ declare const inputSchemaZodObject: z.ZodObject<{
 }, 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>;
+    constructor(mcpServer: McpServer, logger: McpLogger);
+    handler({ userSuppliedName, dest, templateType, absoluteCurrentWorkingDirectory, }: HsCreateTemplateInputSchema, extra?: ToolExtra): Promise<TextContentResponse>;
     register(): RegisteredTool;
 }
 export {};

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

@@ -1,11 +1,9 @@
-import { Tool } from '../../types.js';
+import { Tool } from '../../Tool.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 { HubSpotCommand } from '../../utils/command.js';
 import { setupHubSpotConfig } from '../../utils/config.js';
 import { getErrorMessage } from '../../../lib/errorHandlers/index.js';
 const inputSchema = {
@@ -27,12 +25,11 @@ const inputSchema = {
 const inputSchemaZodObject = z.object({ ...inputSchema });
 const toolName = 'create-cms-template';
 export class HsCreateTemplateTool extends Tool {
-    constructor(mcpServer) {
-        super(mcpServer);
+    constructor(mcpServer, logger) {
+        super(mcpServer, logger, toolName);
     }
-    async handler({ userSuppliedName, dest, templateType, absoluteCurrentWorkingDirectory, }) {
+    async handler({ userSuppliedName, dest, templateType, absoluteCurrentWorkingDirectory, }, extra) {
         setupHubSpotConfig(absoluteCurrentWorkingDirectory);
-        await trackToolUsage(toolName);
         const content = [];
         // Always require a name
         if (!userSuppliedName) {
@@ -49,29 +46,32 @@ export class HsCreateTemplateTool extends Tool {
             };
         }
         // Build the command
-        let command = 'hs create template';
+        const command = new HubSpotCommand('cms template create');
         if (userSuppliedName) {
-            command += ` "${userSuppliedName}"`;
+            command.addArg(userSuppliedName);
         }
         if (dest) {
-            command += ` "${dest}"`;
+            command.addArg(dest);
         }
-        // Add template type flag
         if (templateType) {
-            command = addFlag(command, 'template-type', templateType);
+            command.addFlag('template-type', templateType);
         }
         try {
-            const { stdout, stderr } = await runCommandInDir(absoluteCurrentWorkingDirectory, command);
+            const { stdout, stderr } = await this.runCommand(absoluteCurrentWorkingDirectory, command, extra);
             return formatTextContents(stdout, stderr);
         }
         catch (error) {
+            this.logger.debug(toolName, {
+                message: 'Handler caught error',
+                error: error instanceof Error ? error.message : String(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(', ')}.`,
+            description: `Creates a new HubSpot CMS template using the hs cms template create command. Templates can be created non-interactively by specifying templateType. Supports all template types including: ${TEMPLATE_TYPES.join(', ')}.`,
             inputSchema,
             annotations: {
                 readOnlyHint: false,
@@ -79,6 +79,6 @@ export class HsCreateTemplateTool extends Tool {
                 idempotentHint: false,
                 openWorldHint: false,
             },
-        }, this.handler);
+        }, (input, extra) => this.wrappedHandler(input, extra));
     }
 }

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

@@ -1,5 +1,7 @@
-import { TextContentResponse, Tool } from '../../types.js';
+import { TextContentResponse } from '../../types.js';
+import { Tool, ToolExtra } from '../../Tool.js';
 import { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { McpLogger } from '../../utils/logger.js';
 import { z } from 'zod';
 declare const inputSchemaZodObject: z.ZodObject<{
     absoluteCurrentWorkingDirectory: z.ZodString;
@@ -11,8 +13,8 @@ declare const inputSchemaZodObject: z.ZodObject<{
 }, 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>;
+    constructor(mcpServer: McpServer, logger: McpLogger);
+    handler({ endpoint, account, latest, compact, limit, absoluteCurrentWorkingDirectory, }: HsFunctionLogsInputSchema, extra?: ToolExtra): Promise<TextContentResponse>;
     register(): RegisteredTool;
 }
 export {};