@hubspot/cli 8.10.0 → 8.12.0-beta.0

package/lib/yargs/makeWrappedYargsHandler.js

@@ -1,5 +1,6 @@
 import os from 'os';
 import path from 'path';
+import { z } from 'zod';
 import { getConfig } from '@hubspot/local-dev-lib/config';
 import { getStateValue, setStateValue, } from '@hubspot/local-dev-lib/config/state';
 import { STATE_FLAGS } from '@hubspot/local-dev-lib/constants/config';
@@ -11,7 +12,8 @@ import { lib } from '../../lang/en.js';
 import { EXIT_CODES } from '../enums/exitCodes.js';
 import { isPromptExitError } from '../errors/PromptExitError.js';
 import { debugError } from '../errorHandlers/index.js';
-const HANDLER_LOG_DIR = path.join(os.homedir(), '.hscli', 'logs');
+import { MAX_LOG_FILES } from '../constants.js';
+const HANDLER_LOG_DIR = path.join(os.homedir(), '.hscli', 'logs', 'cli');
 function logUsageTrackingMessage(isJsonOutput) {
     if (isJsonOutput) {
         return;
@@ -32,90 +34,146 @@ function logUsageTrackingMessage(isJsonOutput) {
         return;
     }
 }
-export function makeWrappedYargsHandler(trackingName, handler) {
-    return async (args) => {
-        const startTime = Date.now();
-        const meta = {};
-        let trackingFired = false;
-        const trackingArgs = args;
-        const addUsageMetadata = (newMeta) => {
-            Object.assign(meta, newMeta);
-        };
-        trackingArgs.addUsageMetadata = addUsageMetadata;
-        const trackCommandUsage = async (successful) => {
-            if (trackingFired) {
-                return;
-            }
-            trackingFired = true;
-            try {
-                const { accountId: overrideAccountId, ...trackingMeta } = meta;
-                trackingMeta.successful = successful;
-                trackingMeta.executionTime = Date.now() - startTime;
-                await _trackCommandUsage(trackingName, trackingMeta, overrideAccountId ?? args.derivedAccountId);
+function createUsageTracker(trackingName, derivedAccountId) {
+    const startTime = Date.now();
+    const meta = {};
+    let fired = false;
+    const addMetadata = (newMeta) => {
+        Object.assign(meta, newMeta);
+    };
+    const track = async (successful) => {
+        if (fired) {
+            return;
+        }
+        fired = true;
+        try {
+            const { accountId: overrideAccountId, ...trackingMeta } = meta;
+            trackingMeta.successful = successful;
+            trackingMeta.executionTime = Date.now() - startTime;
+            await _trackCommandUsage(trackingName, trackingMeta, overrideAccountId ?? derivedAccountId);
+        }
+        catch (_e) { }
+    };
+    const onForcedExit = () => {
+        process.exit(EXIT_CODES.SUCCESS);
+    };
+    const onSigint = async () => {
+        process.removeListener('SIGINT', onSigint);
+        process.on('SIGINT', onForcedExit);
+        try {
+            await track(false);
+        }
+        catch (_e) { }
+        process.removeListener('SIGINT', onForcedExit);
+        process.exit(EXIT_CODES.SUCCESS);
+    };
+    process.on('SIGINT', onSigint);
+    const trackAndCleanup = async (successful) => {
+        await track(successful);
+        process.removeListener('SIGINT', onSigint);
+        process.removeListener('SIGINT', onForcedExit);
+    };
+    return { addMetadata, trackAndCleanup };
+}
+function createJsonOutputManager(isJsonOutput, schema) {
+    const data = {};
+    let emitted = false;
+    const add = (newData) => {
+        Object.assign(data, newData);
+    };
+    const emit = () => {
+        if (!emitted && isJsonOutput && Object.keys(data).length > 0) {
+            emitted = true;
+            if (schema) {
+                const result = schema.safeParse(data);
+                if (!result.success) {
+                    uiLogger.json(data);
+                    uiLogger.warn(lib.jsonSchema.validationFailed);
+                    return false;
+                }
             }
-            catch (_e) { }
-        };
-        const onForcedExit = () => {
-            process.exit(EXIT_CODES.SUCCESS);
-        };
-        const onSigint = async () => {
-            process.removeListener('SIGINT', onSigint);
-            process.on('SIGINT', onForcedExit);
-            try {
-                await trackCommandUsage(false);
+            uiLogger.json(data);
+        }
+        return true;
+    };
+    return { add, emit };
+}
+function createLogFileWriter(trackingName, isJsonOutput) {
+    const writeLogFile = () => {
+        if (isJsonOutput) {
+            return null;
+        }
+        return ldlLogger.writeBufferedLogsToFile({
+            dir: HANDLER_LOG_DIR,
+            filenamePrefix: trackingName,
+            maxFiles: MAX_LOG_FILES,
+        });
+    };
+    const writeFailureLogFile = () => {
+        const savedPath = writeLogFile();
+        if (savedPath) {
+            uiLogger.log('');
+            uiLogger.error(lib.handlerLogFile.saved(savedPath));
+        }
+    };
+    return { writeLogFile, writeFailureLogFile };
+}
+export function makeWrappedYargsHandler(trackingName, handler, options) {
+    return async (args) => {
+        const wrappedHandlerArgs = args;
+        const isJsonOutput = Boolean(wrappedHandlerArgs.json || wrappedHandlerArgs.formatOutputAsJson);
+        const schema = options?.jsonOutputSchema;
+        const tracker = createUsageTracker(trackingName, args.derivedAccountId);
+        if (wrappedHandlerArgs.jsonSchema) {
+            if (schema) {
+                uiLogger.json(z.toJSONSchema(schema));
             }
-            catch (_e) { }
-            process.removeListener('SIGINT', onForcedExit);
-            process.exit(EXIT_CODES.SUCCESS);
-        };
-        process.on('SIGINT', onSigint);
-        const trackCommandUsageAndRemoveListeners = async (successful) => {
-            await trackCommandUsage(successful);
-            process.removeListener('SIGINT', onSigint);
-            process.removeListener('SIGINT', onForcedExit);
-        };
-        const jsonArgs = args;
-        const isJsonOutput = Boolean(jsonArgs.json || jsonArgs.formatOutputAsJson);
-        const writeFailureLogFile = () => {
-            // Skip in JSON output modes so the side effect + stderr message don't
-            // interfere with structured output consumers.
-            if (isJsonOutput) {
-                return;
+            else {
+                uiLogger.json({ error: lib.jsonSchema.noSchemaForCommand });
             }
-            const savedPath = ldlLogger.writeBufferedLogsToFile({
-                dir: HANDLER_LOG_DIR,
-                filenamePrefix: trackingName,
-            });
-            if (savedPath) {
-                uiLogger.log('');
-                uiLogger.error(lib.handlerLogFile.saved(savedPath));
+            await tracker.trackAndCleanup(true);
+            return process.exit(EXIT_CODES.SUCCESS);
+        }
+        const json = createJsonOutputManager(isJsonOutput, schema);
+        const logs = createLogFileWriter(trackingName, isJsonOutput);
+        wrappedHandlerArgs.addUsageMetadata = tracker.addMetadata;
+        wrappedHandlerArgs.addJsonOutput = json.add;
+        wrappedHandlerArgs.exit = async (code) => {
+            const jsonValid = json.emit();
+            const exitCode = !jsonValid && code === EXIT_CODES.SUCCESS ? EXIT_CODES.WARNING : code;
+            await tracker.trackAndCleanup(exitCode !== EXIT_CODES.ERROR);
+            if (exitCode === EXIT_CODES.ERROR) {
+                logs.writeFailureLogFile();
             }
-        };
-        trackingArgs.exit = async (code) => {
-            await trackCommandUsageAndRemoveListeners(code !== EXIT_CODES.ERROR);
-            if (code === EXIT_CODES.ERROR) {
-                writeFailureLogFile();
+            else {
+                logs.writeLogFile();
             }
-            return process.exit(code);
+            return process.exit(exitCode);
         };
         logUsageTrackingMessage(isJsonOutput);
         try {
-            await handler(trackingArgs);
+            await handler(wrappedHandlerArgs);
         }
         catch (e) {
             const isSuccessfulPromptExit = isPromptExitError(e)
                 ? e.exitCode !== EXIT_CODES.ERROR
                 : false;
-            await trackCommandUsageAndRemoveListeners(isSuccessfulPromptExit);
+            await tracker.trackAndCleanup(isSuccessfulPromptExit);
             if (isPromptExitError(e)) {
+                logs.writeLogFile();
                 return process.exit(e.exitCode);
             }
             else {
                 debugError(e);
-                writeFailureLogFile();
+                logs.writeFailureLogFile();
                 return process.exit(EXIT_CODES.ERROR);
             }
         }
-        await trackCommandUsageAndRemoveListeners(true);
+        const jsonValid = json.emit();
+        await tracker.trackAndCleanup(true);
+        logs.writeLogFile();
+        if (!jsonValid) {
+            return process.exit(EXIT_CODES.WARNING);
+        }
     };
 }

package/mcp-server/Tool.d.ts

@@ -1,15 +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 getTrackingMeta(input: InputSchema): {
+    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): Promise<TextContentResponse>;
+    protected wrappedHandler(input: InputSchema, extra?: ToolExtra): Promise<TextContentResponse>;
 }

package/mcp-server/Tool.js

@@ -1,6 +1,7 @@
 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;
@@ -13,41 +14,66 @@ export class Tool {
     register() {
         throw new Error('Must implement register');
     }
-    handler(
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    input) {
+    handler(_input) {
         throw new Error('Must implement handler');
     }
-    getTrackingMeta(
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    input) {
+    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;
     }
-    async wrappedHandler(input) {
-        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);
-            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));
-        }
+    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

@@ -17,22 +17,26 @@ WHEN TO USE THIS SERVER
   via \`search-docs\` + \`fetch-doc\` rather than from prior knowledge.
 
 REQUIRED WORKFLOWS
-1. Documentation lookup: always call \`search-docs\` first, then
+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.
-2. Locating a HubSpot project: when the current working directory is not
+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.
-3. Editing \`*-hsmeta.json\`: call \`get-feature-config-schema\` for that
+4. Editing \`*-hsmeta.json\`: call \`get-feature-config-schema\` for that
    feature type first to learn the allowed fields and values.
-4. Debugging a failed build: start with \`get-build-status\` to surface
+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.
-5. Reading serverless function logs: call \`list-cms-serverless-functions\`
+6. Reading serverless function logs: call \`list-cms-serverless-functions\`
    first to discover the endpoint path, then
    \`get-cms-serverless-function-logs\`.
-6. App analytics: call \`get-apps-info\` to discover \`appId\` values
+7. App analytics: call \`get-apps-info\` to discover \`appId\` values
    before \`get-api-usage-patterns-by-app-id\`.
 
 OUTPUT

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

@@ -1,5 +1,5 @@
 import { TextContentResponse } from '../../types.js';
-import { Tool } from '../../Tool.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';
@@ -20,7 +20,7 @@ declare const inputSchemaZodObject: z.ZodObject<{
 export type HsCreateFunctionInputSchema = z.infer<typeof inputSchemaZodObject>;
 export declare class HsCreateFunctionTool extends Tool<HsCreateFunctionInputSchema> {
     constructor(mcpServer: McpServer, logger: McpLogger);
-    handler({ dest, functionsFolder, filename, endpointMethod, endpointPath, absoluteCurrentWorkingDirectory, }: HsCreateFunctionInputSchema): Promise<TextContentResponse>;
+    handler({ dest, functionsFolder, filename, endpointMethod, endpointPath, absoluteCurrentWorkingDirectory, }: HsCreateFunctionInputSchema, extra?: ToolExtra): Promise<TextContentResponse>;
     register(): RegisteredTool;
 }
 export {};

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

@@ -1,10 +1,9 @@
 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 { 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 = {
@@ -37,7 +36,7 @@ export class HsCreateFunctionTool extends Tool {
     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);
         const content = [];
         // Require functions folder
@@ -59,28 +58,22 @@ export class HsCreateFunctionTool extends Tool {
             };
         }
         // Build the command
-        let command = 'hs cms function create';
+        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) {
@@ -102,6 +95,6 @@ export class HsCreateFunctionTool extends Tool {
                 idempotentHint: false,
                 openWorldHint: false,
             },
-        }, input => this.wrappedHandler(input));
+        }, (input, extra) => this.wrappedHandler(input, extra));
     }
 }

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

@@ -1,5 +1,5 @@
 import { TextContentResponse } from '../../types.js';
-import { Tool } from '../../Tool.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';
@@ -16,7 +16,7 @@ declare const inputSchemaZodObject: z.ZodObject<{
 export type HsCreateModuleInputSchema = z.infer<typeof inputSchemaZodObject>;
 export declare class HsCreateModuleTool extends Tool<HsCreateModuleInputSchema> {
     constructor(mcpServer: McpServer, logger: McpLogger);
-    handler({ userSuppliedName, dest, moduleLabel, reactType, contentTypes, global, availableForNewContent, absoluteCurrentWorkingDirectory, }: HsCreateModuleInputSchema): Promise<TextContentResponse>;
+    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,9 +1,9 @@
 import { Tool } from '../../Tool.js';
 import { z } from 'zod';
 import { absoluteCurrentWorkingDirectory } from '../project/constants.js';
-import { addFlag, runCommandInDir } 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 = {
@@ -52,7 +52,7 @@ export class HsCreateModuleTool extends Tool {
     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);
         const content = [];
         // Always require a name
@@ -74,34 +74,28 @@ export class HsCreateModuleTool extends Tool {
             };
         }
         // Build the command
-        let command = 'hs cms module create';
+        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) {
@@ -123,6 +117,6 @@ export class HsCreateModuleTool extends Tool {
                 idempotentHint: false,
                 openWorldHint: false,
             },
-        }, input => this.wrappedHandler(input));
+        }, (input, extra) => this.wrappedHandler(input, extra));
     }
 }

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

@@ -1,5 +1,5 @@
 import { TextContentResponse } from '../../types.js';
-import { Tool } from '../../Tool.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';
@@ -21,7 +21,7 @@ declare const inputSchemaZodObject: z.ZodObject<{
 export type HsCreateTemplateInputSchema = z.infer<typeof inputSchemaZodObject>;
 export declare class HsCreateTemplateTool extends Tool<HsCreateTemplateInputSchema> {
     constructor(mcpServer: McpServer, logger: McpLogger);
-    handler({ userSuppliedName, dest, templateType, absoluteCurrentWorkingDirectory, }: HsCreateTemplateInputSchema): Promise<TextContentResponse>;
+    handler({ userSuppliedName, dest, templateType, absoluteCurrentWorkingDirectory, }: HsCreateTemplateInputSchema, extra?: ToolExtra): Promise<TextContentResponse>;
     register(): RegisteredTool;
 }
 export {};

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

@@ -1,10 +1,9 @@
 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 { 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 = {
@@ -29,7 +28,7 @@ export class HsCreateTemplateTool extends Tool {
     constructor(mcpServer, logger) {
         super(mcpServer, logger, toolName);
     }
-    async handler({ userSuppliedName, dest, templateType, absoluteCurrentWorkingDirectory, }) {
+    async handler({ userSuppliedName, dest, templateType, absoluteCurrentWorkingDirectory, }, extra) {
         setupHubSpotConfig(absoluteCurrentWorkingDirectory);
         const content = [];
         // Always require a name
@@ -47,19 +46,18 @@ export class HsCreateTemplateTool extends Tool {
             };
         }
         // Build the command
-        let command = 'hs cms template create';
+        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) {
@@ -81,6 +79,6 @@ export class HsCreateTemplateTool extends Tool {
                 idempotentHint: false,
                 openWorldHint: false,
             },
-        }, input => this.wrappedHandler(input));
+        }, (input, extra) => this.wrappedHandler(input, extra));
     }
 }

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

@@ -1,5 +1,5 @@
 import { TextContentResponse } from '../../types.js';
-import { Tool } from '../../Tool.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';
@@ -14,7 +14,7 @@ declare const inputSchemaZodObject: z.ZodObject<{
 export type HsFunctionLogsInputSchema = z.infer<typeof inputSchemaZodObject>;
 export declare class HsFunctionLogsTool extends Tool<HsFunctionLogsInputSchema> {
     constructor(mcpServer: McpServer, logger: McpLogger);
-    handler({ endpoint, account, latest, compact, limit, absoluteCurrentWorkingDirectory, }: HsFunctionLogsInputSchema): Promise<TextContentResponse>;
+    handler({ endpoint, account, latest, compact, limit, absoluteCurrentWorkingDirectory, }: HsFunctionLogsInputSchema, extra?: ToolExtra): Promise<TextContentResponse>;
     register(): RegisteredTool;
 }
 export {};