@hubspot/cli 8.2.0 → 8.2.1-experimental.1

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

@@ -1,6 +1,8 @@
 import { z } from 'zod';
 import { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { TextContentResponse, Tool } from '../../types.js';
+import { McpLogger } from '../../utils/logger.js';
+import { TextContentResponse } from '../../types.js';
+import { Tool, ToolExtra } from '../../Tool.js';
 declare const createTestAccountInputSchema: z.ZodObject<{
     absoluteCurrentWorkingDirectory: z.ZodString;
     configPath: z.ZodOptional<z.ZodString>;
@@ -44,8 +46,8 @@ declare const createTestAccountInputSchema: z.ZodObject<{
 }, z.core.$strip>;
 export type CreateTestAccountInputSchema = z.infer<typeof createTestAccountInputSchema>;
 export declare class CreateTestAccountTool extends Tool<CreateTestAccountInputSchema> {
-    constructor(mcpServer: McpServer);
-    handler({ absoluteCurrentWorkingDirectory, name, description, marketingLevel, opsLevel, serviceLevel, salesLevel, contentLevel, commerceLevel, configPath, }: CreateTestAccountInputSchema): Promise<TextContentResponse>;
+    constructor(mcpServer: McpServer, logger: McpLogger);
+    handler({ absoluteCurrentWorkingDirectory, name, description, marketingLevel, opsLevel, serviceLevel, salesLevel, contentLevel, commerceLevel, configPath, }: CreateTestAccountInputSchema, extra?: ToolExtra): Promise<TextContentResponse>;
     register(): RegisteredTool;
 }
 export {};

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

@@ -1,11 +1,9 @@
 import { z } from 'zod';
 import fs from 'fs';
-import { trackToolUsage } from '../../utils/toolUsageTracking.js';
 import { formatTextContents, formatTextContent } from '../../utils/content.js';
-import { addFlag } from '../../utils/command.js';
-import { runCommandInDir } from '../../utils/command.js';
+import { HubSpotCommand } from '../../utils/command.js';
 import { ACCOUNT_LEVELS, ACCOUNT_LEVEL_CHOICES, } from '../../../lib/constants.js';
-import { Tool } from '../../types.js';
+import { Tool } from '../../Tool.js';
 import { absoluteCurrentWorkingDirectory } from './constants.js';
 import { getConfigAccountByName } from '@hubspot/local-dev-lib/config';
 import { setupHubSpotConfig } from '../../utils/config.js';
@@ -58,23 +56,22 @@ const inputSchema = {
     contentLevel: z
         .enum(ACCOUNT_LEVEL_CHOICES)
         .optional()
-        .describe(`CMS Hub tier level. Options: ${ACCOUNT_LEVEL_CHOICES.join(', ')}. Defaults to ENTERPRISE if not specified.`),
+        .describe(`Content Hub tier level. Options: ${ACCOUNT_LEVEL_CHOICES.join(', ')}. Defaults to ENTERPRISE if not specified.`),
     commerceLevel: z
         .enum(ACCOUNT_LEVEL_CHOICES_WITHOUT_STARTER)
         .optional()
-        .describe(`Commerce Hub tier level. Options: ${ACCOUNT_LEVEL_CHOICES_WITHOUT_STARTER.join(', ')}. Defaults to ENTERPRISE if not specified.`),
+        .describe(`Revenue Hub tier level. Options: ${ACCOUNT_LEVEL_CHOICES_WITHOUT_STARTER.join(', ')}. Defaults to ENTERPRISE if not specified.`),
 };
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 const createTestAccountInputSchema = z.object({ ...inputSchema });
 const toolName = 'create-test-account';
 export class CreateTestAccountTool extends Tool {
-    constructor(mcpServer) {
-        super(mcpServer);
+    constructor(mcpServer, logger) {
+        super(mcpServer, logger, toolName);
     }
-    async handler({ absoluteCurrentWorkingDirectory, name, description, marketingLevel, opsLevel, serviceLevel, salesLevel, contentLevel, commerceLevel, configPath, }) {
+    async handler({ absoluteCurrentWorkingDirectory, name, description, marketingLevel, opsLevel, serviceLevel, salesLevel, contentLevel, commerceLevel, configPath, }, extra) {
         setupHubSpotConfig(absoluteCurrentWorkingDirectory);
-        await trackToolUsage(toolName);
-        let command = 'hs test-account create';
+        const command = new HubSpotCommand('test-account create');
         const content = [];
         // Use config file if provided (LLM should check for config first)
         if (configPath) {
@@ -84,6 +81,10 @@ export class CreateTestAccountTool extends Tool {
                 configJson = JSON.parse(config);
             }
             catch (error) {
+                this.logger.debug(toolName, {
+                    message: 'Handler caught error reading config file',
+                    error: error instanceof Error ? error.message : String(error),
+                });
                 return {
                     content: [
                         formatTextContent(`Failed to read or parse config file at "${configPath}": ${getErrorMessage(error)}. Please ensure the file exists and contains valid JSON.`),
@@ -97,10 +98,13 @@ export class CreateTestAccountTool extends Tool {
                     }
                 }
                 catch (error) {
-                    // nothing to do here
+                    this.logger.debug(toolName, {
+                        message: 'Handler caught error checking account by config name',
+                        error: error instanceof Error ? error.message : String(error),
+                    });
                 }
             }
-            command = addFlag(command, 'config-path', configPath);
+            command.addFlag('config-path', configPath);
         }
         // Use flags if name is provided (when no config used)
         else if (name) {
@@ -110,16 +114,19 @@ export class CreateTestAccountTool extends Tool {
                 }
             }
             catch (e) {
-                // nothing to do here
+                this.logger.debug(toolName, {
+                    message: 'Handler caught error checking account by name',
+                    error: e instanceof Error ? e.message : String(e),
+                });
             }
-            command = addFlag(command, 'name', name);
-            command = addFlag(command, 'description', description || name);
-            command = addFlag(command, 'marketing-level', marketingLevel || 'ENTERPRISE');
-            command = addFlag(command, 'ops-level', opsLevel || 'ENTERPRISE');
-            command = addFlag(command, 'service-level', serviceLevel || 'ENTERPRISE');
-            command = addFlag(command, 'sales-level', salesLevel || 'ENTERPRISE');
-            command = addFlag(command, 'content-level', contentLevel || 'ENTERPRISE');
-            command = addFlag(command, 'commerce-level', commerceLevel || 'ENTERPRISE');
+            command.addFlag('name', name);
+            command.addFlag('description', description || name);
+            command.addFlag('marketing-level', marketingLevel || 'ENTERPRISE');
+            command.addFlag('ops-level', opsLevel || 'ENTERPRISE');
+            command.addFlag('service-level', serviceLevel || 'ENTERPRISE');
+            command.addFlag('sales-level', salesLevel || 'ENTERPRISE');
+            command.addFlag('content-level', contentLevel || 'ENTERPRISE');
+            command.addFlag('commerce-level', commerceLevel || 'ENTERPRISE');
         }
         else {
             content.push(formatTextContent(`Ask the user for the account config JSON path or the name of the test account to create.`));
@@ -131,10 +138,14 @@ export class CreateTestAccountTool extends Tool {
         }
         // No flags or config - command will prompt user interactively
         try {
-            const { stdout, stderr } = await runCommandInDir(absoluteCurrentWorkingDirectory, command);
+            const { stdout, stderr } = await this.runCommand(absoluteCurrentWorkingDirectory, command, extra);
             return formatTextContents(absoluteCurrentWorkingDirectory, stdout, stderr);
         }
         catch (error) {
+            this.logger.debug(toolName, {
+                message: 'Handler caught error',
+                error: error instanceof Error ? error.message : String(error),
+            });
             return formatTextContents(absoluteCurrentWorkingDirectory, getErrorMessage(error));
         }
     }
@@ -165,6 +176,6 @@ export class CreateTestAccountTool extends Tool {
                 idempotentHint: false,
                 openWorldHint: true,
             },
-        }, this.handler);
+        }, (input, extra) => this.wrappedHandler(input, extra));
     }
 }

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

package/mcp-server/tools/project/DeployProjectTool.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, absoluteProjectPath, } 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';
 const inputSchema = {
     absoluteProjectPath,
@@ -19,33 +17,33 @@ const inputSchemaZodObject = z.object({
 });
 const toolName = 'deploy-project';
 export class DeployProjectTool extends Tool {
-    constructor(mcpServer) {
-        super(mcpServer);
+    constructor(mcpServer, logger) {
+        super(mcpServer, logger, toolName);
     }
-    async handler({ absoluteProjectPath, absoluteCurrentWorkingDirectory, buildNumber, }) {
+    async handler({ absoluteProjectPath, absoluteCurrentWorkingDirectory, buildNumber, }, extra) {
         setupHubSpotConfig(absoluteCurrentWorkingDirectory);
-        await trackToolUsage(toolName);
-        let command = `hs project deploy`;
         const content = [];
         if (!buildNumber) {
-            const { stdout } = await runCommandInDir(absoluteProjectPath, `hs project list-builds --limit 100`);
+            const { stdout } = await this.runCommand(absoluteProjectPath, new HubSpotCommand('project list-builds', [
+                { name: 'limit', value: 100 },
+            ]), extra);
             content.push(formatTextContent(`Ask the user which build number they would like to deploy?  Build information: ${stdout}`));
         }
-        else {
-            command = addFlag(command, 'build', buildNumber);
-        }
         if (content.length) {
             return {
                 content,
             };
         }
-        const { stdout, stderr } = await runCommandInDir(absoluteProjectPath, command);
+        const command = new HubSpotCommand('project deploy', [
+            { name: 'build', value: buildNumber },
+        ]);
+        const { stdout, stderr } = await this.runCommand(absoluteProjectPath, command, extra);
         return formatTextContents(stdout, stderr);
     }
     register() {
         return this.mcpServer.registerTool(toolName, {
             title: 'Deploy a build of HubSpot Project',
-            description: 'Takes a build number and a project name and deploys that build of the project. DO NOT run this tool unless the user specifies they would like to deploy the project.',
+            description: 'Takes a build number and a project name and deploys that build of the project. DO NOT run this tool unless the user specifies they would like to deploy the project. 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,
@@ -53,6 +51,6 @@ export class DeployProjectTool extends Tool {
                 idempotentHint: true,
                 openWorldHint: true,
             },
-        }, this.handler);
+        }, (input, extra) => this.wrappedHandler(input, extra));
     }
 }

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

@@ -1,13 +1,15 @@
 import { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { McpLogger } from '../../utils/logger.js';
 import z from 'zod';
-import { TextContentResponse, Tool } from '../../types.js';
+import { TextContentResponse } from '../../types.js';
+import { Tool } from '../../Tool.js';
 declare const inputSchemaZodObject: z.ZodObject<{
     docUrl: z.ZodString;
     absoluteCurrentWorkingDirectory: z.ZodString;
 }, z.z.core.$strip>;
 type InputSchemaType = z.infer<typeof inputSchemaZodObject>;
 export declare class DocFetchTool extends Tool<InputSchemaType> {
-    constructor(mcpServer: McpServer);
+    constructor(mcpServer: McpServer, logger: McpLogger);
     handler({ docUrl, absoluteCurrentWorkingDirectory, }: InputSchemaType): Promise<TextContentResponse>;
     register(): RegisteredTool;
 }

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

@@ -1,7 +1,6 @@
 import z from 'zod';
-import { Tool } from '../../types.js';
+import { Tool } from '../../Tool.js';
 import { formatTextContents } from '../../utils/content.js';
-import { trackToolUsage } from '../../utils/toolUsageTracking.js';
 import { absoluteCurrentWorkingDirectory, docUrl } from './constants.js';
 import { http } from '@hubspot/local-dev-lib/http/unauthed';
 import { isHubSpotHttpError } from '@hubspot/local-dev-lib/errors/index';
@@ -17,12 +16,11 @@ const inputSchemaZodObject = z.object({
 });
 const toolName = 'fetch-doc';
 export class DocFetchTool extends Tool {
-    constructor(mcpServer) {
-        super(mcpServer);
+    constructor(mcpServer, logger) {
+        super(mcpServer, logger, toolName);
     }
     async handler({ docUrl, absoluteCurrentWorkingDirectory, }) {
         setupHubSpotConfig(absoluteCurrentWorkingDirectory);
-        await trackToolUsage(toolName);
         try {
             // Append .md extension to the URL
             const markdownUrl = `${docUrl}.md`;
@@ -36,6 +34,10 @@ export class DocFetchTool extends Tool {
             return formatTextContents(content);
         }
         catch (error) {
+            this.logger.debug(toolName, {
+                message: 'Handler caught error',
+                error: error instanceof Error ? error.message : String(error),
+            });
             if (isHubSpotHttpError(error)) {
                 return formatTextContents(error.toString());
             }
@@ -52,6 +54,6 @@ export class DocFetchTool extends Tool {
                 readOnlyHint: true,
                 openWorldHint: true,
             },
-        }, this.handler);
+        }, (input, extra) => this.wrappedHandler(input, extra));
     }
 }

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

@@ -1,9 +1,12 @@
 import { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { McpLogger } from '../../utils/logger.js';
 import z from 'zod';
-import { TextContentResponse, Tool } from '../../types.js';
+import { TextContentResponse } from '../../types.js';
+import { Tool } from '../../Tool.js';
 declare const inputSchemaZodObject: z.ZodObject<{
     absoluteCurrentWorkingDirectory: z.ZodString;
     docsSearchQuery: z.ZodString;
+    docsSearchLimit: z.ZodDefault<z.ZodNumber>;
 }, z.z.core.$strip>;
 export interface DocsSearchResponse {
     results: {
@@ -16,8 +19,11 @@ export interface DocsSearchResponse {
 }
 type InputSchemaType = z.infer<typeof inputSchemaZodObject>;
 export declare class DocsSearchTool extends Tool<InputSchemaType> {
-    constructor(mcpServer: McpServer);
-    handler({ docsSearchQuery, absoluteCurrentWorkingDirectory, }: InputSchemaType): Promise<TextContentResponse>;
+    constructor(mcpServer: McpServer, logger: McpLogger);
+    protected getTrackingMeta({ docsSearchQuery, }: InputSchemaType): {
+        [key: string]: string;
+    } | undefined;
+    handler({ docsSearchQuery, docsSearchLimit, absoluteCurrentWorkingDirectory, }: InputSchemaType): Promise<TextContentResponse>;
     register(): RegisteredTool;
 }
 export {};

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

@@ -1,16 +1,23 @@
 import { http } from '@hubspot/local-dev-lib/http';
 import z from 'zod';
-import { Tool } from '../../types.js';
+import { Tool } from '../../Tool.js';
 import { formatTextContents } from '../../utils/content.js';
-import { trackToolUsage } from '../../utils/toolUsageTracking.js';
 import { absoluteCurrentWorkingDirectory, docsSearchQuery, } from './constants.js';
 import { isHubSpotHttpError } from '@hubspot/local-dev-lib/errors/index';
-import { getConfigDefaultAccountIfExists } from '@hubspot/local-dev-lib/config';
 import { setupHubSpotConfig } from '../../utils/config.js';
+import { discoverAccountTargets } from '../../../lib/accountTargetDiscovery.js';
 import { getErrorMessage } from '../../../lib/errorHandlers/index.js';
+const docsSearchLimit = z
+    .number()
+    .int()
+    .min(1)
+    .max(20)
+    .default(5)
+    .describe('Maximum number of results to return.');
 const inputSchema = {
     absoluteCurrentWorkingDirectory,
     docsSearchQuery,
+    docsSearchLimit,
 };
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 const inputSchemaZodObject = z.object({
@@ -18,18 +25,21 @@ const inputSchemaZodObject = z.object({
 });
 const toolName = 'search-docs';
 export class DocsSearchTool extends Tool {
-    constructor(mcpServer) {
-        super(mcpServer);
+    constructor(mcpServer, logger) {
+        super(mcpServer, logger, toolName);
     }
-    async handler({ docsSearchQuery, absoluteCurrentWorkingDirectory, }) {
+    getTrackingMeta({ docsSearchQuery, }) {
+        return { mode: docsSearchQuery };
+    }
+    async handler({ docsSearchQuery, docsSearchLimit, absoluteCurrentWorkingDirectory, }) {
         setupHubSpotConfig(absoluteCurrentWorkingDirectory);
-        await trackToolUsage(toolName, { mode: docsSearchQuery });
-        const accountId = getConfigDefaultAccountIfExists()?.accountId;
-        if (!accountId) {
-            const authErrorMessage = `No account ID found. Please run \`hs account auth\` to configure an account, or set a default account with \`hs account use <account>\``;
-            return formatTextContents(authErrorMessage);
-        }
         try {
+            const { recommended } = await discoverAccountTargets();
+            const accountId = recommended?.accountId;
+            if (!accountId) {
+                const authErrorMessage = `No account ID found. Call the auth-account tool to authenticate a HubSpot account.`;
+                return formatTextContents(authErrorMessage);
+            }
             const response = await http.post(accountId, {
                 url: 'dev/docs/llms/v1/docs-search',
                 data: {
@@ -40,13 +50,27 @@ export class DocsSearchTool extends Tool {
             if (!results || results.length === 0) {
                 return formatTextContents('No documentation found for your query.');
             }
-            const formattedResults = results
+            // The docs-search API returns duplicate URLs; dedupe to avoid wasting the result limit on repeats
+            const seen = new Set();
+            const dedupedResults = results.filter(result => {
+                if (seen.has(result.url)) {
+                    return false;
+                }
+                seen.add(result.url);
+                return true;
+            });
+            const limitedResults = dedupedResults.slice(0, docsSearchLimit);
+            const formattedResults = limitedResults
                 .map(result => `**${result.title}**\n${result.description}\nURL: ${result.url}\nScore: ${result.score}\n\n${result.content}\n---\n`)
                 .join('\n');
-            const successMessage = `Found ${results.length} documentation results:\n\n${formattedResults}`;
+            const successMessage = `Found ${dedupedResults.length} results, showing top ${limitedResults.length}:\n\n${formattedResults}`;
             return formatTextContents(successMessage);
         }
         catch (error) {
+            this.logger.debug(toolName, {
+                message: 'Handler caught error',
+                error: error instanceof Error ? error.message : String(error),
+            });
             if (isHubSpotHttpError(error)) {
                 // Handle different status codes
                 return formatTextContents(error.toString());
@@ -64,6 +88,6 @@ export class DocsSearchTool extends Tool {
                 readOnlyHint: true,
                 openWorldHint: true,
             },
-        }, this.handler);
+        }, (input, extra) => this.wrappedHandler(input, extra));
     }
 }

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

@@ -0,0 +1,15 @@
+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<{
+    absoluteDirectory: z.ZodString;
+}, z.core.$strip>;
+export type FindProjectsInputSchema = z.infer<typeof inputSchemaZodObject>;
+export declare class FindProjectsTool extends Tool<FindProjectsInputSchema> {
+    constructor(mcpServer: McpServer, logger: McpLogger);
+    handler({ absoluteDirectory, }: FindProjectsInputSchema): Promise<TextContentResponse>;
+    register(): RegisteredTool;
+}
+export {};

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

@@ -0,0 +1,60 @@
+import { Tool } from '../../Tool.js';
+import { z } from 'zod';
+import { formatTextContents } from '../../utils/content.js';
+import { walk } from '@hubspot/local-dev-lib/fs';
+import path from 'path';
+import { PROJECT_CONFIG_FILE } from '../../../lib/constants.js';
+const TOOL_NAME = 'find-projects';
+const IGNORE_DIRS = ['node_modules', '.git', '.vite'];
+const inputSchema = {
+    absoluteDirectory: z
+        .string()
+        .describe('The absolute path to the directory to search for HubSpot projects in.'),
+};
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const inputSchemaZodObject = z.object({ ...inputSchema });
+export class FindProjectsTool extends Tool {
+    constructor(mcpServer, logger) {
+        super(mcpServer, logger, TOOL_NAME);
+    }
+    async handler({ absoluteDirectory, }) {
+        try {
+            const allFiles = await walk(absoluteDirectory, IGNORE_DIRS);
+            const projectFiles = allFiles.filter(file => path.basename(file) === PROJECT_CONFIG_FILE);
+            if (projectFiles.length === 0) {
+                return formatTextContents(`No ${PROJECT_CONFIG_FILE} files found under ${absoluteDirectory}.`);
+            }
+            const projectDirs = projectFiles.map(file => path.dirname(file));
+            const output = [
+                `Found ${projectFiles.length} project(s):`,
+                '',
+                ...projectDirs.map(dir => `  ${dir}`),
+            ].join('\n');
+            return formatTextContents(output);
+        }
+        catch (error) {
+            this.logger.debug(TOOL_NAME, {
+                message: 'Handler caught error',
+                error: error instanceof Error ? error.message : String(error),
+            });
+            const cause = error instanceof Error ? error.cause : undefined;
+            const causeMessage = cause instanceof Error ? `: ${cause.message}` : '';
+            const errorMessage = error instanceof Error
+                ? error.message || `FileSystemError${causeMessage}`
+                : String(error);
+            return formatTextContents(`Error searching for projects: ${errorMessage}`);
+        }
+    }
+    register() {
+        return this.mcpServer.registerTool(TOOL_NAME, {
+            title: 'Find HubSpot Projects',
+            description: 'Use this tool to locate HubSpot projects. Traverses child directories of the given directory to find hsproject.json files, returning the paths of all discovered HubSpot projects.',
+            inputSchema,
+            annotations: {
+                readOnlyHint: true,
+                openWorldHint: false,
+                idempotentHint: true,
+            },
+        }, (input, extra) => this.wrappedHandler(input, extra));
+    }
+}

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

@@ -1,16 +1,19 @@
-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;
+    absoluteProjectPath: z.ZodOptional<z.ZodString>;
     appId: z.ZodString;
     startDate: z.ZodOptional<z.ZodString>;
     endDate: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type GetApiUsagePatternsByAppIdInputSchema = z.infer<typeof inputSchemaZodObject>;
 export declare class GetApiUsagePatternsByAppIdTool extends Tool<GetApiUsagePatternsByAppIdInputSchema> {
-    constructor(mcpServer: McpServer);
-    handler({ appId, startDate, endDate, absoluteCurrentWorkingDirectory, }: GetApiUsagePatternsByAppIdInputSchema): Promise<TextContentResponse>;
+    constructor(mcpServer: McpServer, logger: McpLogger);
+    handler({ appId, startDate, endDate, absoluteCurrentWorkingDirectory, absoluteProjectPath, }: GetApiUsagePatternsByAppIdInputSchema): Promise<TextContentResponse>;
     register(): RegisteredTool;
 }
 export {};

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

@@ -1,15 +1,15 @@
-import { Tool } from '../../types.js';
+import { Tool } from '../../Tool.js';
 import { z } from 'zod';
-import { trackToolUsage } from '../../utils/toolUsageTracking.js';
 import { http } from '@hubspot/local-dev-lib/http';
 import { formatTextContents } from '../../utils/content.js';
 import { isHubSpotHttpError } from '@hubspot/local-dev-lib/errors/index';
-import { getConfigDefaultAccountIfExists } from '@hubspot/local-dev-lib/config';
-import { absoluteCurrentWorkingDirectory } from './constants.js';
+import { absoluteCurrentWorkingDirectory, absoluteProjectPath, } from './constants.js';
 import { setupHubSpotConfig } from '../../utils/config.js';
+import { discoverAccountTargets } from '../../../lib/accountTargetDiscovery.js';
 import { getErrorMessage } from '../../../lib/errorHandlers/index.js';
 const inputSchema = {
     absoluteCurrentWorkingDirectory,
+    absoluteProjectPath: absoluteProjectPath.optional(),
     appId: z
         .string()
         .describe('The numeric app ID as a string (e.g., "3003909"). Must contain only digits. Use get-apps-info to find available app IDs.'),
@@ -26,17 +26,16 @@ const inputSchema = {
 const inputSchemaZodObject = z.object({ ...inputSchema });
 const toolName = 'get-api-usage-patterns-by-app-id';
 export class GetApiUsagePatternsByAppIdTool extends Tool {
-    constructor(mcpServer) {
-        super(mcpServer);
+    constructor(mcpServer, logger) {
+        super(mcpServer, logger, toolName);
     }
-    async handler({ appId, startDate, endDate, absoluteCurrentWorkingDirectory, }) {
-        setupHubSpotConfig(absoluteCurrentWorkingDirectory);
-        await trackToolUsage(toolName);
+    async handler({ appId, startDate, endDate, absoluteCurrentWorkingDirectory, absoluteProjectPath, }) {
+        setupHubSpotConfig(absoluteProjectPath ?? absoluteCurrentWorkingDirectory);
         try {
-            // Get account ID from CLI config
-            const accountId = getConfigDefaultAccountIfExists()?.accountId;
+            const { recommended } = await discoverAccountTargets();
+            const accountId = recommended?.accountId;
             if (!accountId) {
-                const authErrorMessage = `No account ID found. Please run \`hs account auth\` to configure an account, or set a default account with \`hs account use <account>\``;
+                const authErrorMessage = `No account ID found. Call the auth-account tool to authenticate a HubSpot account.`;
                 return formatTextContents(authErrorMessage);
             }
             const response = await http.get(accountId, {
@@ -52,6 +51,10 @@ export class GetApiUsagePatternsByAppIdTool extends Tool {
             return formatTextContents(formattedResult);
         }
         catch (error) {
+            this.logger.debug(toolName, {
+                message: 'Handler caught error',
+                error: error instanceof Error ? error.message : String(error),
+            });
             if (isHubSpotHttpError(error)) {
                 // Handle HubSpot-specific HTTP errors
                 return formatTextContents(error.toString());
@@ -68,6 +71,6 @@ export class GetApiUsagePatternsByAppIdTool extends Tool {
                 readOnlyHint: true,
                 openWorldHint: true,
             },
-        }, this.handler);
+        }, (input, extra) => this.wrappedHandler(input, extra));
     }
 }

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

@@ -1,13 +1,16 @@
-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;
+    absoluteProjectPath: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type GetApplicationInfoInputSchema = z.infer<typeof inputSchemaZodObject>;
 export declare class GetApplicationInfoTool extends Tool<GetApplicationInfoInputSchema> {
-    constructor(mcpServer: McpServer);
-    handler({ absoluteCurrentWorkingDirectory, }: GetApplicationInfoInputSchema): Promise<TextContentResponse>;
+    constructor(mcpServer: McpServer, logger: McpLogger);
+    handler({ absoluteCurrentWorkingDirectory, absoluteProjectPath, }: GetApplicationInfoInputSchema): Promise<TextContentResponse>;
     register(): RegisteredTool;
 }
 export {};