@hubspot/cli 7.10.0-beta.2 → 7.10.0-experimental.0

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

@@ -0,0 +1,26 @@
+import { TextContentResponse, Tool } from '../../types.js';
+import { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+declare const inputSchemaZodObject: z.ZodObject<{
+    absoluteProjectPath: z.ZodString;
+    absoluteCurrentWorkingDirectory: z.ZodString;
+    buildId: z.ZodNumber;
+    logLevel: z.ZodDefault<z.ZodOptional<z.ZodEnum<["ERROR", "WARN", "INFO", "ALL"]>>>;
+}, "strip", z.ZodTypeAny, {
+    buildId: number;
+    absoluteProjectPath: string;
+    absoluteCurrentWorkingDirectory: string;
+    logLevel: "ERROR" | "WARN" | "INFO" | "ALL";
+}, {
+    buildId: number;
+    absoluteProjectPath: string;
+    absoluteCurrentWorkingDirectory: string;
+    logLevel?: "ERROR" | "WARN" | "INFO" | "ALL" | undefined;
+}>;
+export type GetBuildLogsInputSchema = z.infer<typeof inputSchemaZodObject>;
+export declare class GetBuildLogsTool extends Tool<GetBuildLogsInputSchema> {
+    constructor(mcpServer: McpServer);
+    handler({ absoluteProjectPath, absoluteCurrentWorkingDirectory, buildId, logLevel, }: GetBuildLogsInputSchema): Promise<TextContentResponse>;
+    register(): RegisteredTool;
+}
+export {};

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

@@ -0,0 +1,125 @@
+import { Tool } from '../../types.js';
+import { z } from 'zod';
+import { trackToolUsage } from '../../utils/toolUsageTracking.js';
+import { formatTextContents } from '../../utils/content.js';
+import { isHubSpotHttpError } from '@hubspot/local-dev-lib/errors/index';
+import { http } from '@hubspot/local-dev-lib/http';
+import { getProjectConfig, validateProjectConfig, } from '../../../lib/projects/config.js';
+import { absoluteCurrentWorkingDirectory, absoluteProjectPath, } from './constants.js';
+import { getConfigDefaultAccountIfExists } from '@hubspot/local-dev-lib/config';
+import { setupHubSpotConfig } from '../../utils/config.js';
+const TOOL_NAME = 'get-build-logs';
+const PROJECTS_LOGS_API_PATH = 'dfs/logging/v1';
+const inputSchema = {
+    absoluteProjectPath,
+    absoluteCurrentWorkingDirectory,
+    buildId: z
+        .number()
+        .describe('Build ID to fetch logs for. Use get-build-status to find recent build IDs.'),
+    logLevel: z
+        .enum(['ERROR', 'WARN', 'INFO', 'ALL'])
+        .optional()
+        .default('ALL')
+        .describe('Filter logs by level. ERROR: Show only errors, WARN: Show only warnings, INFO: Show only info, ALL: Show all logs.'),
+};
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const inputSchemaZodObject = z.object({ ...inputSchema });
+function flattenLogs(response) {
+    const allLogs = [];
+    response.logs.forEach(substep => {
+        substep.logs.forEach(log => {
+            allLogs.push(log);
+        });
+    });
+    return allLogs.sort((a, b) => a.timestamp - b.timestamp);
+}
+function filterLogsByLevel(logs, logLevel) {
+    if (logLevel === 'ALL') {
+        return logs;
+    }
+    return logs.filter(log => log.logLevel === logLevel);
+}
+function formatLogs(logs) {
+    if (logs.length === 0) {
+        return 'No logs found.';
+    }
+    return logs
+        .map(log => {
+        const timestamp = new Date(log.timestamp).toLocaleString('en-US', {
+            month: 'short',
+            day: 'numeric',
+            year: 'numeric',
+            hour: 'numeric',
+            minute: 'numeric',
+            second: 'numeric',
+            timeZoneName: 'short',
+        });
+        const component = log.pipelineSubstepName || `Step ${log.pipelineStepId}`;
+        return `[${log.logLevel}][${component}] ${timestamp} ${log.message}`;
+    })
+        .join('\n');
+}
+export class GetBuildLogsTool extends Tool {
+    constructor(mcpServer) {
+        super(mcpServer);
+    }
+    async handler({ absoluteProjectPath, absoluteCurrentWorkingDirectory, buildId, logLevel, }) {
+        setupHubSpotConfig(absoluteCurrentWorkingDirectory);
+        await trackToolUsage(TOOL_NAME);
+        try {
+            const accountId = getConfigDefaultAccountIfExists()?.accountId;
+            if (!accountId) {
+                return formatTextContents(absoluteCurrentWorkingDirectory, 'No account ID found. Please run `hs account auth` to configure an account, or set a default account with `hs account use <account>`');
+            }
+            const { projectConfig, projectDir } = await getProjectConfig(absoluteProjectPath);
+            validateProjectConfig(projectConfig, projectDir);
+            const projectName = projectConfig.name;
+            const response = await http.get(accountId, {
+                url: `${PROJECTS_LOGS_API_PATH}/logs/projects/${encodeURIComponent(projectName)}/builds/${buildId}`,
+            });
+            const buildLogsResponse = response.data;
+            if (!buildLogsResponse.logs || buildLogsResponse.logs.length === 0) {
+                return formatTextContents(absoluteCurrentWorkingDirectory, `No logs found for build #${buildId} in project '${projectName}'.`);
+            }
+            const allLogs = flattenLogs(buildLogsResponse);
+            if (allLogs.length === 0) {
+                return formatTextContents(absoluteCurrentWorkingDirectory, `No logs found for build #${buildId} in project '${projectName}'.`);
+            }
+            const filteredLogs = filterLogsByLevel(allLogs, logLevel);
+            let output;
+            if (filteredLogs.length === 0) {
+                // No logs match filter, show all logs instead
+                output = `No ${logLevel} level logs found for build #${buildId} in '${projectName}'.\nShowing all logs instead:\n\n${formatLogs(allLogs)}`;
+            }
+            else {
+                output = `Logs for build #${buildId} in '${projectName}' (${logLevel} level):\n\n${formatLogs(filteredLogs)}`;
+            }
+            return formatTextContents(absoluteCurrentWorkingDirectory, output);
+        }
+        catch (error) {
+            let errorMessage;
+            if (isHubSpotHttpError(error)) {
+                errorMessage = error.toString();
+            }
+            else if (error instanceof Error) {
+                errorMessage = error.message;
+            }
+            else {
+                errorMessage = String(error);
+            }
+            return formatTextContents(absoluteCurrentWorkingDirectory, errorMessage);
+        }
+    }
+    register() {
+        return this.mcpServer.registerTool(TOOL_NAME, {
+            title: 'Get HubSpot Project Build Logs',
+            description: 'Retrieves build logs for a specific HubSpot project build. Use this to debug build failures by viewing the full build pipeline output. This tool is for more comprehensive troubleshootings or addressing build WARNINGs, build errors should be troubleshooted with get-build-status tool first. Logs can be filtered by level (ERROR, WARN, INFO, or ALL). Use `hs project list-builds`  first to identify the build ID and error messages.',
+            inputSchema,
+            annotations: {
+                readOnlyHint: true,
+                openWorldHint: true,
+                idempotentHint: true,
+            },
+        }, this.handler);
+    }
+}

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

@@ -0,0 +1,26 @@
+import { TextContentResponse, Tool } from '../../types.js';
+import { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+declare const inputSchemaZodObject: z.ZodObject<{
+    absoluteProjectPath: z.ZodString;
+    absoluteCurrentWorkingDirectory: z.ZodString;
+    buildId: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    limit: number;
+    absoluteProjectPath: string;
+    absoluteCurrentWorkingDirectory: string;
+    buildId?: number | undefined;
+}, {
+    absoluteProjectPath: string;
+    absoluteCurrentWorkingDirectory: string;
+    limit?: number | undefined;
+    buildId?: number | undefined;
+}>;
+export type GetBuildStatusInputSchema = z.infer<typeof inputSchemaZodObject>;
+export declare class GetBuildStatusTool extends Tool<GetBuildStatusInputSchema> {
+    constructor(mcpServer: McpServer);
+    handler({ absoluteProjectPath, absoluteCurrentWorkingDirectory, buildId, limit, }: GetBuildStatusInputSchema): Promise<TextContentResponse>;
+    register(): RegisteredTool;
+}
+export {};

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

@@ -0,0 +1,166 @@
+import { Tool } from '../../types.js';
+import { z } from 'zod';
+import { trackToolUsage } from '../../utils/toolUsageTracking.js';
+import { formatTextContents } from '../../utils/content.js';
+import { isHubSpotHttpError } from '@hubspot/local-dev-lib/errors/index';
+import { fetchProjectBuilds, getBuildStatus, } from '@hubspot/local-dev-lib/api/projects';
+import { getProjectConfig, validateProjectConfig, } from '../../../lib/projects/config.js';
+import moment from 'moment';
+import { absoluteCurrentWorkingDirectory, absoluteProjectPath, } from './constants.js';
+import { getConfigDefaultAccountIfExists } from '@hubspot/local-dev-lib/config';
+import { setupHubSpotConfig } from '../../utils/config.js';
+const TOOL_NAME = 'get-build-status';
+const inputSchema = {
+    absoluteProjectPath,
+    absoluteCurrentWorkingDirectory,
+    buildId: z
+        .number()
+        .optional()
+        .describe('Optional: Specific build ID to inspect. If omitted, shows recent builds to help identify the latest build.'),
+    limit: z
+        .number()
+        .optional()
+        .default(3)
+        .describe('Number of recent builds to fetch when buildId is not specified.'),
+};
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const inputSchemaZodObject = z.object({ ...inputSchema });
+function getStatusIcon(status) {
+    return status === 'SUCCESS' ? '✓' : '⚠️';
+}
+function formatDuration(startedAt, finishedAt) {
+    const duration = moment.duration(moment(finishedAt).diff(moment(startedAt)));
+    const days = Math.floor(duration.asDays());
+    const hours = duration.hours();
+    const minutes = duration.minutes();
+    const seconds = duration.seconds();
+    const parts = [];
+    if (days > 0)
+        parts.push(`${days}d`);
+    if (hours > 0)
+        parts.push(`${hours}h`);
+    if (minutes > 0)
+        parts.push(`${minutes}m`);
+    if (seconds > 0 || parts.length === 0)
+        parts.push(`${seconds}s`);
+    return parts.join(' ');
+}
+function formatSubbuilds(subbuilds, indent = '  ') {
+    const lines = [];
+    subbuilds.forEach(sub => {
+        const icon = getStatusIcon(sub.status);
+        lines.push(`${indent}${icon} ${sub.buildName} (${sub.buildType}): ${sub.status}`);
+        if (sub.errorMessage) {
+            lines.push(`${indent}  Error: ${sub.errorMessage}`);
+        }
+    });
+    return lines;
+}
+function formatBuildList(builds) {
+    const lines = [];
+    builds.forEach((build, index) => {
+        const icon = getStatusIcon(build.status);
+        const timeAgo = moment(build.finishedAt).fromNow();
+        const duration = formatDuration(build.startedAt, build.finishedAt);
+        lines.push(`Build #${build.buildId} - ${build.status} ${icon}`);
+        lines.push(`  Finished: ${timeAgo} (Duration: ${duration})`);
+        if (build.uploadMessage) {
+            lines.push(`  Message: ${build.uploadMessage}`);
+        }
+        if (build.status === 'FAILURE' && build.buildErrorMessage) {
+            lines.push(`  Error: ${build.buildErrorMessage}`);
+        }
+        if (build.subbuildStatuses.length > 0) {
+            lines.push(`  Subbuilds:`);
+            lines.push(...formatSubbuilds(build.subbuildStatuses, '    '));
+        }
+        if (index < builds.length - 1) {
+            lines.push('');
+        }
+    });
+    return lines.join('\n');
+}
+function formatBuildDetails(build) {
+    const lines = [];
+    const icon = getStatusIcon(build.status);
+    lines.push(`Build #${build.buildId} Details\n`);
+    lines.push(`Status: ${build.status} ${icon}`);
+    lines.push(`Platform Version: ${build.platformVersion}`);
+    lines.push(`Started: ${moment(build.startedAt).format('YYYY-MM-DD HH:mm:ss UTC')}`);
+    lines.push(`Finished: ${moment(build.finishedAt).format('YYYY-MM-DD HH:mm:ss UTC')}`);
+    lines.push(`Duration: ${formatDuration(build.startedAt, build.finishedAt)}`);
+    if (build.uploadMessage) {
+        lines.push(`\nUpload Message:\n${build.uploadMessage}`);
+    }
+    if (build.buildErrorMessage) {
+        lines.push(`\nBuild Error:\n${build.buildErrorMessage}`);
+    }
+    if (build.subbuildStatuses.length > 0) {
+        lines.push(`\nSubbuilds:`);
+        lines.push(...formatSubbuilds(build.subbuildStatuses));
+    }
+    else {
+        lines.push(`\nSubbuilds: None`);
+    }
+    return lines.join('\n');
+}
+export class GetBuildStatusTool extends Tool {
+    constructor(mcpServer) {
+        super(mcpServer);
+    }
+    async handler({ absoluteProjectPath, absoluteCurrentWorkingDirectory, buildId, limit, }) {
+        setupHubSpotConfig(absoluteCurrentWorkingDirectory);
+        await trackToolUsage(TOOL_NAME);
+        try {
+            const accountId = getConfigDefaultAccountIfExists()?.accountId;
+            if (!accountId) {
+                return formatTextContents(absoluteCurrentWorkingDirectory, 'No account ID found. Please run `hs account auth` to configure an account, or set a default account with `hs account use <account>`');
+            }
+            const { projectConfig, projectDir } = await getProjectConfig(absoluteProjectPath);
+            validateProjectConfig(projectConfig, projectDir);
+            const projectName = projectConfig.name;
+            let output;
+            if (buildId) {
+                const response = await getBuildStatus(accountId, projectName, buildId);
+                const build = response.data;
+                output = formatBuildDetails(build);
+            }
+            else {
+                const response = await fetchProjectBuilds(accountId, projectName, {
+                    limit,
+                });
+                const { results } = response.data;
+                if (!results || results.length === 0) {
+                    return formatTextContents(absoluteCurrentWorkingDirectory, `No builds found for project '${projectName}'.`);
+                }
+                output = `Recent builds for '${projectName}':\n\n${formatBuildList(results)}`;
+            }
+            return formatTextContents(absoluteCurrentWorkingDirectory, output);
+        }
+        catch (error) {
+            let errorMessage;
+            if (isHubSpotHttpError(error)) {
+                errorMessage = error.toString();
+            }
+            else if (error instanceof Error) {
+                errorMessage = error.message;
+            }
+            else {
+                errorMessage = String(error);
+            }
+            return formatTextContents(absoluteCurrentWorkingDirectory, errorMessage);
+        }
+    }
+    register() {
+        return this.mcpServer.registerTool(TOOL_NAME, {
+            title: 'Get HubSpot Projects Build Status and Errors',
+            description: 'Retrieves build status and error messages for HubSpot projects. When buildId is omitted, shows recent builds with their status(default 3) - use this to find the latest builds when troubleshooting. When buildId is provided, shows detailed error information for that specific build. Displays buildErrorMessage and subbuild failures to help diagnose build issues.',
+            inputSchema,
+            annotations: {
+                readOnlyHint: true,
+                openWorldHint: true,
+                idempotentHint: true,
+            },
+        }, this.handler);
+    }
+}

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

@@ -17,7 +17,7 @@ declare const inputSchemaZodObject: z.ZodObject<{
 type InputSchemaType = z.infer<typeof inputSchemaZodObject>;
 export declare class GetConfigValuesTool extends Tool<InputSchemaType> {
     constructor(mcpServer: McpServer);
-    handler({ absoluteCurrentWorkingDirectory, platformVersion, featureType, }: InputSchemaType): Promise<TextContentResponse>;
+    handler({ platformVersion, featureType, absoluteCurrentWorkingDirectory, }: InputSchemaType): Promise<TextContentResponse>;
     register(): RegisteredTool;
 }
 export {};

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

@@ -4,7 +4,8 @@ import { formatTextContents } from '../../utils/content.js';
 import { absoluteCurrentWorkingDirectory } from './constants.js';
 import { getIntermediateRepresentationSchema, mapToInternalType, } from '@hubspot/project-parsing-lib';
 import { isV2Project } from '../../../lib/projects/platformVersion.js';
-import { getAccountIdFromCliConfig } from '../../utils/cliConfig.js';
+import { getConfigDefaultAccountIfExists } from '@hubspot/local-dev-lib/config';
+import { setupHubSpotConfig } from '../../utils/config.js';
 const inputSchema = {
     absoluteCurrentWorkingDirectory,
     platformVersion: z
@@ -23,15 +24,16 @@ export class GetConfigValuesTool extends Tool {
     constructor(mcpServer) {
         super(mcpServer);
     }
-    async handler({ absoluteCurrentWorkingDirectory, platformVersion, featureType, }) {
+    async handler({ platformVersion, featureType, absoluteCurrentWorkingDirectory, }) {
+        setupHubSpotConfig(absoluteCurrentWorkingDirectory);
         try {
             if (!isV2Project(platformVersion)) {
-                return formatTextContents(absoluteCurrentWorkingDirectory, `Can only be used on projects with a minimum platformVersion of 2025.2`);
+                return formatTextContents(`Can only be used on projects with a minimum platformVersion of 2025.2`);
             }
-            const accountId = getAccountIdFromCliConfig(absoluteCurrentWorkingDirectory);
+            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(absoluteCurrentWorkingDirectory, authErrorMessage);
+                return formatTextContents(authErrorMessage);
             }
             const schema = await getIntermediateRepresentationSchema({
                 platformVersion,
@@ -40,11 +42,11 @@ export class GetConfigValuesTool extends Tool {
             });
             const internalComponentType = mapToInternalType(featureType);
             if (schema[internalComponentType]) {
-                return formatTextContents(absoluteCurrentWorkingDirectory, JSON.stringify({ config: schema[internalComponentType] }));
+                return formatTextContents(JSON.stringify({ config: schema[internalComponentType] }));
             }
         }
         catch (error) { }
-        return formatTextContents(absoluteCurrentWorkingDirectory, `Unable to locate JSON schema for type ${featureType}`);
+        return formatTextContents(`Unable to locate JSON schema for type ${featureType}`);
     }
     register() {
         return this.mcpServer.registerTool(toolName, {

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

@@ -14,7 +14,7 @@ declare const inputSchemaZodObject: z.ZodObject<{
 type InputSchemaType = z.infer<typeof inputSchemaZodObject>;
 export declare class GuidedWalkthroughTool extends Tool<InputSchemaType> {
     constructor(mcpServer: McpServer);
-    handler({ absoluteCurrentWorkingDirectory, command, }: InputSchemaType): Promise<TextContentResponse>;
+    handler({ command, absoluteCurrentWorkingDirectory, }: InputSchemaType): Promise<TextContentResponse>;
     register(): RegisteredTool;
 }
 export {};

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

@@ -4,6 +4,7 @@ import { execAsync } from '../../utils/command.js';
 import { formatTextContents } from '../../utils/content.js';
 import { trackToolUsage } from '../../utils/toolUsageTracking.js';
 import { absoluteCurrentWorkingDirectory } from './constants.js';
+import { setupHubSpotConfig } from '../../utils/config.js';
 const nextCommands = {
     'hs init': 'hs auth',
     'hs auth': 'hs project create',
@@ -31,13 +32,14 @@ export class GuidedWalkthroughTool extends Tool {
     constructor(mcpServer) {
         super(mcpServer);
     }
-    async handler({ absoluteCurrentWorkingDirectory, command, }) {
+    async handler({ command, absoluteCurrentWorkingDirectory, }) {
+        setupHubSpotConfig(absoluteCurrentWorkingDirectory);
         await trackToolUsage(toolName);
         if (command) {
             const { stdout } = await execAsync(`${command} --help`);
-            return formatTextContents(absoluteCurrentWorkingDirectory, `Display this help output for the user amd wait for them to acknowledge: ${stdout}. ${nextCommands[command] ? `Once they are ready, A good command to look at next is ${nextCommands[command]}` : ''}`);
+            return formatTextContents(`Display this help output for the user amd wait for them to acknowledge: ${stdout}. ${nextCommands[command] ? `Once they are ready, A good command to look at next is ${nextCommands[command]}` : ''}`);
         }
-        return formatTextContents(absoluteCurrentWorkingDirectory, 'Is there another command you would like to learn more about?');
+        return formatTextContents('Is there another command you would like to learn more about?');
     }
     register() {
         return this.mcpServer.registerTool(toolName, {

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

@@ -8,6 +8,7 @@ import { absoluteCurrentWorkingDirectory, absoluteProjectPath, } from './constan
 import { formatTextContent, formatTextContents } from '../../utils/content.js';
 import { trackToolUsage } from '../../utils/toolUsageTracking.js';
 import { addFlag } from '../../utils/command.js';
+import { setupHubSpotConfig } from '../../utils/config.js';
 const inputSchema = {
     absoluteProjectPath,
     absoluteCurrentWorkingDirectory,
@@ -28,6 +29,7 @@ export class UploadProjectTools extends Tool {
         super(mcpServer);
     }
     async handler({ absoluteProjectPath, absoluteCurrentWorkingDirectory, profile, uploadMessage, }) {
+        setupHubSpotConfig(absoluteCurrentWorkingDirectory);
         await trackToolUsage(toolName);
         let command = addFlag('hs project upload', 'force-create', true);
         const content = [];
@@ -60,7 +62,7 @@ export class UploadProjectTools extends Tool {
             };
         }
         const { stdout, stderr } = await runCommandInDir(absoluteProjectPath, command);
-        return formatTextContents(absoluteCurrentWorkingDirectory, stdout, stderr);
+        return formatTextContents(stdout, stderr);
     }
     register() {
         return this.mcpServer.registerTool(toolName, {

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

@@ -4,6 +4,7 @@ import { absoluteCurrentWorkingDirectory, absoluteProjectPath, } from './constan
 import { runCommandInDir } from '../../utils/project.js';
 import { formatTextContents } from '../../utils/content.js';
 import { trackToolUsage } from '../../utils/toolUsageTracking.js';
+import { setupHubSpotConfig } from '../../utils/config.js';
 const inputSchema = {
     absoluteProjectPath,
     absoluteCurrentWorkingDirectory,
@@ -16,13 +17,14 @@ export class ValidateProjectTool extends Tool {
         super(mcpServer);
     }
     async handler({ absoluteProjectPath, absoluteCurrentWorkingDirectory, }) {
+        setupHubSpotConfig(absoluteCurrentWorkingDirectory);
         await trackToolUsage(toolName);
         try {
             const { stdout, stderr } = await runCommandInDir(absoluteProjectPath, 'hs project validate');
-            return formatTextContents(absoluteCurrentWorkingDirectory, stdout, stderr);
+            return formatTextContents(stdout, stderr);
         }
         catch (error) {
-            return formatTextContents(absoluteCurrentWorkingDirectory, error instanceof Error ? error.message : `${error}`);
+            return formatTextContents(error instanceof Error ? error.message : `${error}`);
         }
     }
     register() {

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

@@ -3,16 +3,19 @@ import { runCommandInDir } from '../../../utils/project.js';
 import { addFlag } from '../../../utils/command.js';
 import { mcpFeedbackRequest } from '../../../utils/feedbackTracking.js';
 import fs from 'fs';
+import * as config from '@hubspot/local-dev-lib/config';
 vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
 vi.mock('../../../utils/project');
 vi.mock('../../../utils/command');
 vi.mock('../../../utils/toolUsageTracking');
 vi.mock('../../../utils/feedbackTracking');
 vi.mock('fs');
+vi.mock('@hubspot/local-dev-lib/config');
 const mockMcpFeedbackRequest = mcpFeedbackRequest;
 const mockRunCommandInDir = runCommandInDir;
 const mockAddFlag = addFlag;
 const mockReadFileSync = fs.readFileSync;
+const mockGetConfigAccountByName = vi.spyOn(config, 'getConfigAccountByName');
 describe('mcp-server/tools/project/CreateTestAccountTool', () => {
     let mockMcpServer;
     let tool;
@@ -35,6 +38,8 @@ describe('mcp-server/tools/project/CreateTestAccountTool', () => {
             description: 'Test description',
             marketingLevel: 'PROFESSIONAL',
         }));
+        // @ts-expect-error breaking things
+        mockGetConfigAccountByName.mockReturnValue(undefined);
     });
     describe('register', () => {
         it('should register tool with correct parameters', () => {
@@ -80,6 +85,7 @@ describe('mcp-server/tools/project/CreateTestAccountTool', () => {
                 expect(mockRunCommandInDir).toHaveBeenCalledWith('/test/workspace', 'hs test-account create --config-path "./test-account.json"');
                 expect(result).toEqual({
                     content: [
+                        { type: 'text', text: '/test/workspace' },
                         {
                             type: 'text',
                             text: 'Test account created successfully\nAccount ID: 12345678',
@@ -350,7 +356,7 @@ describe('mcp-server/tools/project/CreateTestAccountTool', () => {
                 const result = await tool.handler(input);
                 expect(mockRunCommandInDir).toHaveBeenCalled();
                 expect(mockAddFlag).toHaveBeenCalledTimes(7);
-                expect(result.content[0]).toEqual({
+                expect(result.content[1]).toEqual({
                     type: 'text',
                     text: 'Test account created with defaults',
                 });
@@ -413,6 +419,7 @@ describe('mcp-server/tools/project/CreateTestAccountTool', () => {
                 const result = await tool.handler(input);
                 expect(result).toEqual({
                     content: [
+                        { type: 'text', text: '/test/workspace' },
                         { type: 'text', text: 'Test account created successfully' },
                         {
                             type: 'text',
@@ -436,7 +443,10 @@ describe('mcp-server/tools/project/CreateTestAccountTool', () => {
                 };
                 const result = await tool.handler(input);
                 expect(result).toEqual({
-                    content: [{ type: 'text', text: 'Failed to create test account' }],
+                    content: [
+                        { type: 'text', text: '/test/workspace' },
+                        { type: 'text', text: 'Failed to create test account' },
+                    ],
                 });
             });
         });

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

@@ -2,12 +2,15 @@ import { DocFetchTool } from '../DocFetchTool.js';
 import { http } from '@hubspot/local-dev-lib/http/unauthed';
 import { isHubSpotHttpError } from '@hubspot/local-dev-lib/errors/index';
 import { mcpFeedbackRequest } from '../../../utils/feedbackTracking.js';
+import { trackToolUsage } from '../../../utils/toolUsageTracking.js';
 vi.mock('@modelcontextprotocol/sdk/server/mcp.js');
 vi.mock('@hubspot/local-dev-lib/http/unauthed');
 vi.mock('@hubspot/local-dev-lib/errors/index');
-vi.mock('../../utils/toolUsageTracking');
+vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('../../../utils/toolUsageTracking');
 vi.mock('../../../utils/feedbackTracking');
 const mockMcpFeedbackRequest = mcpFeedbackRequest;
+const mockTrackToolUsage = trackToolUsage;
 const mockHttp = http;
 const mockIsHubSpotHttpError = vi.mocked(isHubSpotHttpError);
 describe('mcp-server/tools/project/DocFetchTool', () => {
@@ -23,6 +26,7 @@ describe('mcp-server/tools/project/DocFetchTool', () => {
         mockRegisteredTool = {};
         mockMcpServer.registerTool.mockReturnValue(mockRegisteredTool);
         mockMcpFeedbackRequest.mockResolvedValue('');
+        mockTrackToolUsage.mockResolvedValue(undefined);
         tool = new DocFetchTool(mockMcpServer);
     });
     describe('register', () => {