@hubspot/cli 8.2.0 → 8.2.1-experimental.0

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

@@ -1,10 +1,8 @@
-import { Tool } from '../../types.js';
+import { Tool } from '../../Tool.js';
 import { z } from 'zod';
-import { addFlag } from '../../utils/command.js';
+import { HubSpotCommand } from '../../utils/command.js';
 import { absoluteCurrentWorkingDirectory } from '../project/constants.js';
-import { runCommandInDir } from '../../utils/command.js';
 import { formatTextContents } from '../../utils/content.js';
-import { trackToolUsage } from '../../utils/toolUsageTracking.js';
 import { setupHubSpotConfig } from '../../utils/config.js';
 import { getErrorMessage } from '../../../lib/errorHandlers/index.js';
 const inputSchema = {
@@ -30,34 +28,37 @@ const inputSchema = {
 const inputSchemaZodObject = z.object({ ...inputSchema });
 const toolName = 'get-cms-serverless-function-logs';
 export class HsFunctionLogsTool extends Tool {
-    constructor(mcpServer) {
-        super(mcpServer);
+    constructor(mcpServer, logger) {
+        super(mcpServer, logger, toolName);
     }
-    async handler({ endpoint, account, latest, compact, limit, absoluteCurrentWorkingDirectory, }) {
+    async handler({ endpoint, account, latest, compact, limit, absoluteCurrentWorkingDirectory, }, extra) {
         setupHubSpotConfig(absoluteCurrentWorkingDirectory);
-        await trackToolUsage(toolName);
         // Ensure endpoint doesn't start with '/'
         const normalizedEndpoint = endpoint.startsWith('/')
             ? endpoint.slice(1)
             : endpoint;
-        let command = `hs logs ${normalizedEndpoint}`;
+        const command = new HubSpotCommand(`cms function logs ${normalizedEndpoint}`);
         if (latest) {
-            command = addFlag(command, 'latest', latest);
+            command.addFlag('latest', latest);
         }
         if (compact) {
-            command = addFlag(command, 'compact', compact);
+            command.addFlag('compact', compact);
         }
         if (limit) {
-            command = addFlag(command, 'limit', limit);
+            command.addFlag('limit', limit);
         }
         if (account) {
-            command = addFlag(command, 'account', account);
+            command.addFlag('account', account);
         }
         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(`Error executing hs logs command: ${getErrorMessage(error)}`);
         }
     }
@@ -70,6 +71,6 @@ export class HsFunctionLogsTool extends Tool {
                 readOnlyHint: true,
                 openWorldHint: true,
             },
-        }, this.handler);
+        }, (input, extra) => this.wrappedHandler(input, extra));
     }
 }

package/mcp-server/tools/cms/HsListFunctionsTool.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;
@@ -8,8 +10,8 @@ declare const inputSchemaZodObject: z.ZodObject<{
 }, z.core.$strip>;
 export type HsListFunctionsInputSchema = z.infer<typeof inputSchemaZodObject>;
 export declare class HsListFunctionsTool extends Tool<HsListFunctionsInputSchema> {
-    constructor(mcpServer: McpServer);
-    handler({ account, json, absoluteCurrentWorkingDirectory, }: HsListFunctionsInputSchema): Promise<TextContentResponse>;
+    constructor(mcpServer: McpServer, logger: McpLogger);
+    handler({ account, json, absoluteCurrentWorkingDirectory, }: HsListFunctionsInputSchema, extra?: ToolExtra): Promise<TextContentResponse>;
     register(): RegisteredTool;
 }
 export {};

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

@@ -1,10 +1,8 @@
-import { Tool } from '../../types.js';
+import { Tool } from '../../Tool.js';
 import { z } from 'zod';
-import { addFlag } from '../../utils/command.js';
+import { HubSpotCommand } from '../../utils/command.js';
 import { absoluteCurrentWorkingDirectory } from '../project/constants.js';
-import { runCommandInDir } from '../../utils/command.js';
 import { formatTextContents } from '../../utils/content.js';
-import { trackToolUsage } from '../../utils/toolUsageTracking.js';
 import { setupHubSpotConfig } from '../../utils/config.js';
 import { getErrorMessage } from '../../../lib/errorHandlers/index.js';
 const inputSchema = {
@@ -22,24 +20,27 @@ const inputSchema = {
 const inputSchemaZodObject = z.object({ ...inputSchema });
 const toolName = 'list-cms-serverless-functions';
 export class HsListFunctionsTool extends Tool {
-    constructor(mcpServer) {
-        super(mcpServer);
+    constructor(mcpServer, logger) {
+        super(mcpServer, logger, toolName);
     }
-    async handler({ account, json, absoluteCurrentWorkingDirectory, }) {
+    async handler({ account, json, absoluteCurrentWorkingDirectory, }, extra) {
         setupHubSpotConfig(absoluteCurrentWorkingDirectory);
-        await trackToolUsage(toolName);
-        let command = 'hs function list';
+        const command = new HubSpotCommand('cms function list');
         if (json) {
-            command += ' --json';
+            command.addFlag('json', true);
         }
         if (account) {
-            command = addFlag(command, 'account', account);
+            command.addFlag('account', account);
         }
         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 {
                 content: [
                     {
@@ -59,6 +60,6 @@ export class HsListFunctionsTool extends Tool {
                 readOnlyHint: true,
                 openWorldHint: true,
             },
-        }, this.handler);
+        }, (input, extra) => this.wrappedHandler(input, extra));
     }
 }

package/mcp-server/tools/cms/HsListTool.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;
@@ -8,8 +10,8 @@ declare const inputSchemaZodObject: z.ZodObject<{
 }, z.core.$strip>;
 export type HsListInputSchema = z.infer<typeof inputSchemaZodObject>;
 export declare class HsListTool extends Tool<HsListInputSchema> {
-    constructor(mcpServer: McpServer);
-    handler({ path, account, absoluteCurrentWorkingDirectory, }: HsListInputSchema): Promise<TextContentResponse>;
+    constructor(mcpServer: McpServer, logger: McpLogger);
+    handler({ path, account, absoluteCurrentWorkingDirectory }: HsListInputSchema, extra?: ToolExtra): Promise<TextContentResponse>;
     register(): RegisteredTool;
 }
 export {};

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

@@ -1,10 +1,8 @@
-import { Tool } from '../../types.js';
+import { Tool } from '../../Tool.js';
 import { z } from 'zod';
-import { addFlag } from '../../utils/command.js';
+import { HubSpotCommand } from '../../utils/command.js';
 import { absoluteCurrentWorkingDirectory } from '../project/constants.js';
-import { runCommandInDir } from '../../utils/command.js';
 import { formatTextContents } from '../../utils/content.js';
-import { trackToolUsage } from '../../utils/toolUsageTracking.js';
 import { setupHubSpotConfig } from '../../utils/config.js';
 import { getErrorMessage } from '../../../lib/errorHandlers/index.js';
 const inputSchema = {
@@ -22,29 +20,29 @@ const inputSchema = {
 const inputSchemaZodObject = z.object({ ...inputSchema });
 const toolName = 'list-cms-remote-contents';
 export class HsListTool extends Tool {
-    constructor(mcpServer) {
-        super(mcpServer);
+    constructor(mcpServer, logger) {
+        super(mcpServer, logger, toolName);
     }
-    async handler({ path, account, absoluteCurrentWorkingDirectory, }) {
+    async handler({ path, account, absoluteCurrentWorkingDirectory }, extra) {
         setupHubSpotConfig(absoluteCurrentWorkingDirectory);
-        await trackToolUsage(toolName);
-        let command = 'hs list';
-        if (path) {
-            command += ` ${path}`;
-        }
+        const command = new HubSpotCommand(path ? `cms list ${path}` : 'cms list');
         if (account) {
-            command = addFlag(command, 'account', account);
+            command.addFlag('account', account);
         }
         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 {
                 content: [
                     {
                         type: 'text',
-                        text: `Error executing hs list command: ${getErrorMessage(error)}`,
+                        text: `Error executing hs cms list command: ${getErrorMessage(error)}`,
                     },
                 ],
             };
@@ -59,6 +57,6 @@ export class HsListTool extends Tool {
                 readOnlyHint: true,
                 openWorldHint: true,
             },
-        }, this.handler);
+        }, (input, extra) => this.wrappedHandler(input, extra));
     }
 }

package/mcp-server/tools/index.d.ts

@@ -1,3 +1,4 @@
 import { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
-export declare function registerProjectTools(mcpServer: McpServer): RegisteredTool[];
-export declare function registerCmsTools(mcpServer: McpServer): RegisteredTool[];
+import { McpLogger } from '../utils/logger.js';
+export declare function registerProjectTools(mcpServer: McpServer, logger: McpLogger): RegisteredTool[];
+export declare function registerCmsTools(mcpServer: McpServer, logger: McpLogger): RegisteredTool[];

package/mcp-server/tools/index.js

@@ -18,31 +18,35 @@ import { HsCreateFunctionTool } from './cms/HsCreateFunctionTool.js';
 import { HsListFunctionsTool } from './cms/HsListFunctionsTool.js';
 import { HsFunctionLogsTool } from './cms/HsFunctionLogsTool.js';
 import { CreateTestAccountTool } from './project/CreateTestAccountTool.js';
-export function registerProjectTools(mcpServer) {
+import { FindProjectsTool } from './project/FindProjectsTool.js';
+import { AuthAccountTool } from './project/AuthAccountTool.js';
+export function registerProjectTools(mcpServer, logger) {
     return [
-        new UploadProjectTools(mcpServer).register(),
-        new CreateProjectTool(mcpServer).register(),
-        new GuidedWalkthroughTool(mcpServer).register(),
-        new CreateTestAccountTool(mcpServer).register(),
-        new DeployProjectTool(mcpServer).register(),
-        new AddFeatureToProjectTool(mcpServer).register(),
-        new ValidateProjectTool(mcpServer).register(),
-        new GetConfigValuesTool(mcpServer).register(),
-        new DocsSearchTool(mcpServer).register(),
-        new DocFetchTool(mcpServer).register(),
-        new GetApiUsagePatternsByAppIdTool(mcpServer).register(),
-        new GetApplicationInfoTool(mcpServer).register(),
-        new GetBuildLogsTool(mcpServer).register(),
-        new GetBuildStatusTool(mcpServer).register(),
+        new UploadProjectTools(mcpServer, logger).register(),
+        new CreateProjectTool(mcpServer, logger).register(),
+        new GuidedWalkthroughTool(mcpServer, logger).register(),
+        new CreateTestAccountTool(mcpServer, logger).register(),
+        new DeployProjectTool(mcpServer, logger).register(),
+        new AddFeatureToProjectTool(mcpServer, logger).register(),
+        new ValidateProjectTool(mcpServer, logger).register(),
+        new GetConfigValuesTool(mcpServer, logger).register(),
+        new DocsSearchTool(mcpServer, logger).register(),
+        new DocFetchTool(mcpServer, logger).register(),
+        new GetApiUsagePatternsByAppIdTool(mcpServer, logger).register(),
+        new GetApplicationInfoTool(mcpServer, logger).register(),
+        new GetBuildLogsTool(mcpServer, logger).register(),
+        new GetBuildStatusTool(mcpServer, logger).register(),
+        new FindProjectsTool(mcpServer, logger).register(),
+        new AuthAccountTool(mcpServer, logger).register(),
     ];
 }
-export function registerCmsTools(mcpServer) {
+export function registerCmsTools(mcpServer, logger) {
     return [
-        new HsListTool(mcpServer).register(),
-        new HsCreateModuleTool(mcpServer).register(),
-        new HsCreateTemplateTool(mcpServer).register(),
-        new HsCreateFunctionTool(mcpServer).register(),
-        new HsListFunctionsTool(mcpServer).register(),
-        new HsFunctionLogsTool(mcpServer).register(),
+        new HsListTool(mcpServer, logger).register(),
+        new HsCreateModuleTool(mcpServer, logger).register(),
+        new HsCreateTemplateTool(mcpServer, logger).register(),
+        new HsCreateFunctionTool(mcpServer, logger).register(),
+        new HsListFunctionsTool(mcpServer, logger).register(),
+        new HsFunctionLogsTool(mcpServer, logger).register(),
     ];
 }

package/mcp-server/tools/project/AddFeatureToProjectTool.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<{
     absoluteProjectPath: z.ZodString;
@@ -18,18 +20,20 @@ declare const inputSchemaZodObject: z.ZodObject<{
         settings: "settings";
         "app-event": "app-event";
         "workflow-action-tool": "workflow-action-tool";
+        "crm-bulk-action": "crm-bulk-action";
         page: "page";
         webhooks: "webhooks";
-        "workflow-action": "workflow-action";
         "app-function": "app-function";
         "app-object": "app-object";
         scim: "scim";
+        "workflow-action": "workflow-action";
+        "app-function-endpoint": "app-function-endpoint";
     }>>>;
 }, z.core.$strip>;
 export type AddFeatureInputSchema = z.infer<typeof inputSchemaZodObject>;
 export declare class AddFeatureToProjectTool extends Tool<AddFeatureInputSchema> {
-    constructor(mcpServer: McpServer);
-    handler({ absoluteProjectPath, absoluteCurrentWorkingDirectory, distribution, auth, features, addApp, }: AddFeatureInputSchema): Promise<TextContentResponse>;
+    constructor(mcpServer: McpServer, logger: McpLogger);
+    handler({ absoluteProjectPath, absoluteCurrentWorkingDirectory, distribution, auth, features, addApp, }: AddFeatureInputSchema, extra?: ToolExtra): Promise<TextContentResponse>;
     register(): RegisteredTool;
 }
 export {};

package/mcp-server/tools/project/AddFeatureToProjectTool.js

@@ -1,11 +1,9 @@
-import { Tool } from '../../types.js';
+import { Tool } from '../../Tool.js';
 import { z } from 'zod';
 import { APP_AUTH_TYPES, APP_DISTRIBUTION_TYPES, } from '../../../lib/constants.js';
-import { addFlag } from '../../utils/command.js';
+import { HubSpotCommand } from '../../utils/command.js';
 import { absoluteCurrentWorkingDirectory, absoluteProjectPath, features, } from './constants.js';
-import { runCommandInDir } from '../../utils/command.js';
 import { formatTextContents, formatTextContent } from '../../utils/content.js';
-import { trackToolUsage } from '../../utils/toolUsageTracking.js';
 import { setupHubSpotConfig } from '../../utils/config.js';
 import { getErrorMessage } from '../../../lib/errorHandlers/index.js';
 const inputSchema = {
@@ -30,23 +28,22 @@ const inputSchemaZodObject = z.object({
 });
 const toolName = 'add-feature-to-project';
 export class AddFeatureToProjectTool extends Tool {
-    constructor(mcpServer) {
-        super(mcpServer);
+    constructor(mcpServer, logger) {
+        super(mcpServer, logger, toolName);
     }
-    async handler({ absoluteProjectPath, absoluteCurrentWorkingDirectory, distribution, auth, features, addApp, }) {
+    async handler({ absoluteProjectPath, absoluteCurrentWorkingDirectory, distribution, auth, features, addApp, }, extra) {
         setupHubSpotConfig(absoluteCurrentWorkingDirectory);
         try {
-            await trackToolUsage(toolName);
-            let command = `hs project add`;
+            const command = new HubSpotCommand('project add');
             const content = [];
             if (distribution) {
-                command = addFlag(command, 'distribution', distribution);
+                command.addFlag('distribution', distribution);
             }
             else if (addApp) {
                 content.push(formatTextContent(`Ask the user how they would you like to distribute the app. Options are ${APP_DISTRIBUTION_TYPES.MARKETPLACE} and ${APP_DISTRIBUTION_TYPES.PRIVATE}`));
             }
             if (auth) {
-                command = addFlag(command, 'auth', auth);
+                command.addFlag('auth', auth);
             }
             else if (addApp) {
                 content.push(formatTextContent(`Ask the user which auth type they would like to use. Options are ${APP_AUTH_TYPES.STATIC} and ${APP_AUTH_TYPES.OAUTH}`));
@@ -57,11 +54,15 @@ export class AddFeatureToProjectTool extends Tool {
                 };
             }
             // If features isn't provided, pass an empty array to bypass the prompt
-            command = addFlag(command, 'features', features || []);
-            const { stdout, stderr } = await runCommandInDir(absoluteProjectPath, command);
+            command.addFlag('features', features || []);
+            const { stdout, stderr } = await this.runCommand(absoluteProjectPath, 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));
         }
     }
@@ -69,7 +70,7 @@ export class AddFeatureToProjectTool extends Tool {
         return this.mcpServer.registerTool(toolName, {
             title: 'Add feature to HubSpot Project',
             description: `Adds a feature to an existing HubSpot project.
-          Only works for projects with platformVersion '2025.2' and beyond`,
+          Only works for projects with platformVersion '2025.2' and beyond. If you do not know the project path, use the find-projects tool first to locate HubSpot projects in the workspace.`,
             inputSchema,
             annotations: {
                 readOnlyHint: false,
@@ -77,6 +78,6 @@ export class AddFeatureToProjectTool extends Tool {
                 idempotentHint: false,
                 openWorldHint: false,
             },
-        }, this.handler);
+        }, (input, extra) => this.wrappedHandler(input, extra));
     }
 }

package/mcp-server/tools/project/AuthAccountTool.d.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { McpLogger } from '../../utils/logger.js';
+import { Tool, ToolExtra } from '../../Tool.js';
+import { TextContentResponse } from '../../types.js';
+declare const inputSchemaZodObject: z.ZodObject<{
+    absoluteCurrentWorkingDirectory: z.ZodString;
+    accountId: z.ZodOptional<z.ZodNumber>;
+    name: z.ZodOptional<z.ZodString>;
+    setAsDefault: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type AuthAccountInputSchema = z.infer<typeof inputSchemaZodObject>;
+export declare class AuthAccountTool extends Tool<AuthAccountInputSchema> {
+    constructor(mcpServer: McpServer, logger: McpLogger);
+    handler({ absoluteCurrentWorkingDirectory, accountId, name, setAsDefault, }: AuthAccountInputSchema, extra?: ToolExtra): Promise<TextContentResponse>;
+    register(): RegisteredTool;
+}
+export {};

package/mcp-server/tools/project/AuthAccountTool.js

@@ -0,0 +1,78 @@
+import { z } from 'zod';
+import { Tool } from '../../Tool.js';
+import { formatTextContents } from '../../utils/content.js';
+import { HubSpotCommand } from '../../utils/command.js';
+import { setupHubSpotConfig } from '../../utils/config.js';
+import { absoluteCurrentWorkingDirectory } from './constants.js';
+import { getErrorMessage } from '../../../lib/errorHandlers/index.js';
+const inputSchema = {
+    absoluteCurrentWorkingDirectory,
+    accountId: z
+        .number()
+        .optional()
+        .describe('The HubSpot portal ID to authenticate.'),
+    name: z
+        .string()
+        .optional()
+        .describe('A name to assign to this account in the HubSpot CLI config. Defaults to the portal name if not provided.'),
+    setAsDefault: z
+        .boolean()
+        .optional()
+        .describe('Set this account as the default for CLI operations. Defaults to true when not specified.'),
+};
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const inputSchemaZodObject = z.object({ ...inputSchema });
+const toolName = 'auth-account';
+export class AuthAccountTool extends Tool {
+    constructor(mcpServer, logger) {
+        super(mcpServer, logger, toolName);
+    }
+    async handler({ absoluteCurrentWorkingDirectory, accountId, name, setAsDefault, }, extra) {
+        setupHubSpotConfig(absoluteCurrentWorkingDirectory);
+        const command = new HubSpotCommand('account auth');
+        if (name) {
+            command.addFlag('name', name);
+        }
+        else {
+            command.addFlag('use-default-name', 'true');
+        }
+        if (accountId !== undefined) {
+            command.addFlag('account', accountId);
+        }
+        command.addFlag('default', setAsDefault === false ? 'false' : 'true');
+        try {
+            const { stdout, stderr } = await this.runCommand(absoluteCurrentWorkingDirectory, command, extra);
+            return formatTextContents(stdout, stderr);
+        }
+        catch (error) {
+            this.logger.debug(toolName, {
+                message: 'Handler caught error running hs account auth',
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return formatTextContents(getErrorMessage(error));
+        }
+    }
+    register() {
+        return this.mcpServer.registerTool(toolName, {
+            title: 'Authenticate a HubSpot Account',
+            description: 'Authenticates a HubSpot account with the CLI using `hs account auth`.\n\n' +
+                'WHEN TO USE:\n' +
+                '- The user wants to add or authenticate a HubSpot account\n' +
+                '- Any other tool reports that no account is configured\n' +
+                '- The user asks how to connect their HubSpot account to the CLI\n\n' +
+                'WORKFLOW:\n' +
+                '1. Call this tool — it opens a browser tab for the user to authorize\n' +
+                '2. The user clicks "Connect to CLI" in the browser\n' +
+                '3. Auth completes automatically via WebSocket\n' +
+                '4. Retry any operation that was blocked by missing auth\n\n' +
+                'setAsDefault defaults to true. Pass setAsDefault: false to keep an existing default account.',
+            inputSchema,
+            annotations: {
+                readOnlyHint: false,
+                destructiveHint: false,
+                idempotentHint: false,
+                openWorldHint: true,
+            },
+        }, (input, extra) => this.wrappedHandler(input, extra));
+    }
+}

package/mcp-server/tools/project/CreateProjectTool.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;
@@ -22,18 +24,20 @@ declare const inputSchemaZodObject: z.ZodObject<{
         settings: "settings";
         "app-event": "app-event";
         "workflow-action-tool": "workflow-action-tool";
+        "crm-bulk-action": "crm-bulk-action";
         page: "page";
         webhooks: "webhooks";
-        "workflow-action": "workflow-action";
         "app-function": "app-function";
         "app-object": "app-object";
         scim: "scim";
+        "workflow-action": "workflow-action";
+        "app-function-endpoint": "app-function-endpoint";
     }>>>;
 }, z.core.$strip>;
 export type CreateProjectInputSchema = z.infer<typeof inputSchemaZodObject>;
 export declare class CreateProjectTool extends Tool<CreateProjectInputSchema> {
-    constructor(mcpServer: McpServer);
-    handler({ name, destination, projectBase, distribution, auth, features, absoluteCurrentWorkingDirectory, }: CreateProjectInputSchema): Promise<TextContentResponse>;
+    constructor(mcpServer: McpServer, logger: McpLogger);
+    handler({ name, destination, projectBase, distribution, auth, features, absoluteCurrentWorkingDirectory, }: CreateProjectInputSchema, extra?: ToolExtra): Promise<TextContentResponse>;
     register(): RegisteredTool;
 }
 export {};

package/mcp-server/tools/project/CreateProjectTool.js

@@ -1,13 +1,12 @@
-import { Tool } from '../../types.js';
+import { Tool } from '../../Tool.js';
 import { z } from 'zod';
 import { APP_AUTH_TYPES, APP_DISTRIBUTION_TYPES, EMPTY_PROJECT, PROJECT_WITH_APP, } from '../../../lib/constants.js';
-import { addFlag } from '../../utils/command.js';
+import { HubSpotCommand } from '../../utils/command.js';
 import { absoluteCurrentWorkingDirectory, features } from './constants.js';
-import { runCommandInDir } from '../../utils/command.js';
 import { formatTextContents, formatTextContent } from '../../utils/content.js';
-import { trackToolUsage } from '../../utils/toolUsageTracking.js';
 import { setupHubSpotConfig } from '../../utils/config.js';
 import { getErrorMessage } from '../../../lib/errorHandlers/index.js';
+import { PLATFORM_VERSIONS } from '@hubspot/project-parsing-lib/constants';
 const inputSchema = {
     absoluteCurrentWorkingDirectory,
     name: z
@@ -34,34 +33,35 @@ const inputSchema = {
 const inputSchemaZodObject = z.object({ ...inputSchema });
 const toolName = 'create-project';
 export class CreateProjectTool extends Tool {
-    constructor(mcpServer) {
-        super(mcpServer);
+    constructor(mcpServer, logger) {
+        super(mcpServer, logger, toolName);
     }
-    async handler({ name, destination, projectBase, distribution, auth, features, absoluteCurrentWorkingDirectory, }) {
+    async handler({ name, destination, projectBase, distribution, auth, features, absoluteCurrentWorkingDirectory, }, extra) {
         setupHubSpotConfig(absoluteCurrentWorkingDirectory);
-        await trackToolUsage(toolName);
-        let command = addFlag('hs project create', 'platform-version', '2025.2');
+        const command = new HubSpotCommand('project create', [
+            { name: 'platform-version', value: PLATFORM_VERSIONS.v2026_03 },
+        ]);
         const content = [];
         if (name) {
-            command = addFlag(command, 'name', name);
+            command.addFlag('name', name);
         }
         else {
             content.push(formatTextContent(`Ask the user what they would like to name the project.`));
         }
         if (destination) {
-            command = addFlag(command, 'dest', destination);
+            command.addFlag('dest', destination);
         }
         if (projectBase) {
-            command = addFlag(command, 'project-base', projectBase);
+            command.addFlag('project-base', projectBase);
         }
         if (distribution) {
-            command = addFlag(command, 'distribution', distribution);
+            command.addFlag('distribution', distribution);
         }
         else if (projectBase === PROJECT_WITH_APP) {
             content.push(formatTextContent(`Ask the user how they would you like to distribute the app? Options are ${APP_DISTRIBUTION_TYPES.MARKETPLACE} and ${APP_DISTRIBUTION_TYPES.PRIVATE}`));
         }
         if (auth) {
-            command = addFlag(command, 'auth', auth);
+            command.addFlag('auth', auth);
         }
         else if (projectBase === PROJECT_WITH_APP) {
             content.push(formatTextContent(`Ask the user which auth type they would like to use? Options are ${APP_AUTH_TYPES.STATIC} and ${APP_AUTH_TYPES.OAUTH}`));
@@ -72,12 +72,16 @@ export class CreateProjectTool extends Tool {
             };
         }
         // Always pass features, even if it is an empty array to bypass the prompts
-        command = addFlag(command, 'features', features || []);
+        command.addFlag('features', features || []);
         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));
         }
     }
@@ -92,6 +96,6 @@ export class CreateProjectTool extends Tool {
                 idempotentHint: false,
                 openWorldHint: false,
             },
-        }, this.handler);
+        }, (input, extra) => this.wrappedHandler(input, extra));
     }
 }