@hubspot/cli 8.1.0 → 8.1.2-experimental.0

package/mcp-server/server.js

@@ -1,13 +1,53 @@
 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. 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
+   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
+   feature type first to learn the allowed fields and values.
+4. 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\`
+   first to discover the endpoint path, then
+   \`get-cms-serverless-function-logs\`.
+6. 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 } 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,7 +19,7 @@ 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);
+    constructor(mcpServer: McpServer, logger: McpLogger);
     handler({ dest, functionsFolder, filename, endpointMethod, endpointPath, absoluteCurrentWorkingDirectory, }: HsCreateFunctionInputSchema): Promise<TextContentResponse>;
     register(): RegisteredTool;
 }

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

@@ -1,9 +1,8 @@
-import { Tool } from '../../types.js';
+import { Tool } from '../../Tool.js';
 import { z } from 'zod';
 import { absoluteCurrentWorkingDirectory } from '../project/constants.js';
-import { runCommandInDir } from '../../utils/project.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 { setupHubSpotConfig } from '../../utils/config.js';
@@ -35,12 +34,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, }) {
         setupHubSpotConfig(absoluteCurrentWorkingDirectory);
-        await trackToolUsage(toolName);
         const content = [];
         // Require functions folder
         if (!functionsFolder) {
@@ -61,7 +59,7 @@ export class HsCreateFunctionTool extends Tool {
             };
         }
         // Build the command
-        let command = 'hs create function';
+        let command = 'hs cms function create';
         if (dest) {
             command += ` "${dest}"`;
         }
@@ -86,13 +84,17 @@ export class HsCreateFunctionTool extends Tool {
             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 +102,6 @@ export class HsCreateFunctionTool extends Tool {
                 idempotentHint: false,
                 openWorldHint: false,
             },
-        }, this.handler);
+        }, input => this.wrappedHandler(input));
     }
 }

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 } 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,7 +15,7 @@ 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);
+    constructor(mcpServer: McpServer, logger: McpLogger);
     handler({ userSuppliedName, dest, moduleLabel, reactType, contentTypes, global, availableForNewContent, absoluteCurrentWorkingDirectory, }: HsCreateModuleInputSchema): Promise<TextContentResponse>;
     register(): RegisteredTool;
 }

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

@@ -1,10 +1,8 @@
-import { Tool } from '../../types.js';
+import { Tool } from '../../Tool.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 { addFlag, runCommandInDir } from '../../utils/command.js';
+import { formatTextContent, formatTextContents } from '../../utils/content.js';
 import { CONTENT_TYPES } from '../../../types/Cms.js';
 import { setupHubSpotConfig } from '../../utils/config.js';
 import { getErrorMessage } from '../../../lib/errorHandlers/index.js';
@@ -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, }) {
         setupHubSpotConfig(absoluteCurrentWorkingDirectory);
-        await trackToolUsage(toolName);
         const content = [];
         // Always require a name
         if (!userSuppliedName) {
@@ -77,7 +74,7 @@ export class HsCreateModuleTool extends Tool {
             };
         }
         // Build the command
-        let command = 'hs create module';
+        let command = 'hs cms module create';
         if (userSuppliedName) {
             command += ` "${userSuppliedName}"`;
         }
@@ -108,13 +105,17 @@ export class HsCreateModuleTool extends Tool {
             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 +123,6 @@ export class HsCreateModuleTool extends Tool {
                 idempotentHint: false,
                 openWorldHint: false,
             },
-        }, this.handler);
+        }, input => this.wrappedHandler(input));
     }
 }

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 } 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,7 +20,7 @@ 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);
+    constructor(mcpServer: McpServer, logger: McpLogger);
     handler({ userSuppliedName, dest, templateType, absoluteCurrentWorkingDirectory, }: HsCreateTemplateInputSchema): Promise<TextContentResponse>;
     register(): RegisteredTool;
 }

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

@@ -1,9 +1,8 @@
-import { Tool } from '../../types.js';
+import { Tool } from '../../Tool.js';
 import { z } from 'zod';
 import { absoluteCurrentWorkingDirectory } from '../project/constants.js';
-import { runCommandInDir } from '../../utils/project.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 { setupHubSpotConfig } from '../../utils/config.js';
@@ -27,12 +26,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, }) {
         setupHubSpotConfig(absoluteCurrentWorkingDirectory);
-        await trackToolUsage(toolName);
         const content = [];
         // Always require a name
         if (!userSuppliedName) {
@@ -49,7 +47,7 @@ export class HsCreateTemplateTool extends Tool {
             };
         }
         // Build the command
-        let command = 'hs create template';
+        let command = 'hs cms template create';
         if (userSuppliedName) {
             command += ` "${userSuppliedName}"`;
         }
@@ -65,13 +63,17 @@ export class HsCreateTemplateTool extends Tool {
             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 +81,6 @@ export class HsCreateTemplateTool extends Tool {
                 idempotentHint: false,
                 openWorldHint: false,
             },
-        }, this.handler);
+        }, input => this.wrappedHandler(input));
     }
 }

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 } 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,7 +13,7 @@ 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);
+    constructor(mcpServer: McpServer, logger: McpLogger);
     handler({ endpoint, account, latest, compact, limit, absoluteCurrentWorkingDirectory, }: HsFunctionLogsInputSchema): Promise<TextContentResponse>;
     register(): RegisteredTool;
 }

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 { addFlag, runCommandInDir } 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';
 import { setupHubSpotConfig } from '../../utils/config.js';
 import { getErrorMessage } from '../../../lib/errorHandlers/index.js';
 const inputSchema = {
@@ -30,17 +28,16 @@ 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, }) {
         setupHubSpotConfig(absoluteCurrentWorkingDirectory);
-        await trackToolUsage(toolName);
         // Ensure endpoint doesn't start with '/'
         const normalizedEndpoint = endpoint.startsWith('/')
             ? endpoint.slice(1)
             : endpoint;
-        let command = `hs logs ${normalizedEndpoint}`;
+        let command = `hs cms function logs ${normalizedEndpoint}`;
         if (latest) {
             command = addFlag(command, 'latest', latest);
         }
@@ -58,6 +55,10 @@ export class HsFunctionLogsTool extends Tool {
             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 => this.wrappedHandler(input));
     }
 }

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 } 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,7 +10,7 @@ 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);
+    constructor(mcpServer: McpServer, logger: McpLogger);
     handler({ account, json, absoluteCurrentWorkingDirectory, }: HsListFunctionsInputSchema): Promise<TextContentResponse>;
     register(): RegisteredTool;
 }

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 { addFlag, runCommandInDir } 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';
 import { setupHubSpotConfig } from '../../utils/config.js';
 import { getErrorMessage } from '../../../lib/errorHandlers/index.js';
 const inputSchema = {
@@ -22,13 +20,12 @@ 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, }) {
         setupHubSpotConfig(absoluteCurrentWorkingDirectory);
-        await trackToolUsage(toolName);
-        let command = 'hs function list';
+        let command = 'hs cms function list';
         if (json) {
             command += ' --json';
         }
@@ -40,6 +37,10 @@ export class HsListFunctionsTool extends Tool {
             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 => this.wrappedHandler(input));
     }
 }

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 } 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,7 +10,7 @@ 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);
+    constructor(mcpServer: McpServer, logger: McpLogger);
     handler({ path, account, absoluteCurrentWorkingDirectory, }: HsListInputSchema): Promise<TextContentResponse>;
     register(): RegisteredTool;
 }

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

@@ -1,10 +1,9 @@
-import { Tool } from '../../types.js';
+import { Tool } from '../../Tool.js';
 import { z } from 'zod';
 import { addFlag } from '../../utils/command.js';
 import { absoluteCurrentWorkingDirectory } from '../project/constants.js';
-import { runCommandInDir } from '../../utils/project.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,13 +21,12 @@ 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, }) {
         setupHubSpotConfig(absoluteCurrentWorkingDirectory);
-        await trackToolUsage(toolName);
-        let command = 'hs list';
+        let command = 'hs cms list';
         if (path) {
             command += ` ${path}`;
         }
@@ -40,11 +38,15 @@ export class HsListTool extends Tool {
             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 +61,6 @@ export class HsListTool extends Tool {
                 readOnlyHint: true,
                 openWorldHint: true,
             },
-        }, this.handler);
+        }, input => this.wrappedHandler(input));
     }
 }

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,33 @@ 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';
+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(),
     ];
 }
-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,17 +1,37 @@
-import { TextContentResponse, Tool } from '../../types.js';
+import { TextContentResponse } from '../../types.js';
+import { Tool } 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;
     absoluteCurrentWorkingDirectory: z.ZodString;
     addApp: z.ZodBoolean;
-    distribution: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"marketplace">, z.ZodLiteral<"private">]>>;
-    auth: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"static">, z.ZodLiteral<"oauth">]>>;
-    features: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodLiteral<"card">, z.ZodLiteral<"settings">, z.ZodLiteral<"app-function">, z.ZodLiteral<"webhooks">, z.ZodLiteral<"workflow-action">, z.ZodLiteral<"workflow-action-tool">, z.ZodLiteral<"app-object">, z.ZodLiteral<"app-event">, z.ZodLiteral<"scim">, z.ZodLiteral<"page">]>>>;
+    distribution: z.ZodOptional<z.ZodEnum<{
+        marketplace: "marketplace";
+        private: "private";
+    }>>;
+    auth: z.ZodOptional<z.ZodEnum<{
+        oauth: "oauth";
+        static: "static";
+    }>>;
+    features: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        card: "card";
+        settings: "settings";
+        "app-event": "app-event";
+        "workflow-action-tool": "workflow-action-tool";
+        page: "page";
+        webhooks: "webhooks";
+        "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);
+    constructor(mcpServer: McpServer, logger: McpLogger);
     handler({ absoluteProjectPath, absoluteCurrentWorkingDirectory, distribution, auth, features, addApp, }: AddFeatureInputSchema): Promise<TextContentResponse>;
     register(): RegisteredTool;
 }