@hubspot/cli 8.0.10-experimental.6 → 8.0.11-experimental.0

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

@@ -0,0 +1,57 @@
+import z from 'zod';
+import { Tool } from '../../types.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';
+import { setupHubSpotConfig } from '../../utils/config.js';
+import { getErrorMessage } from '../../../lib/errorHandlers/index.js';
+const inputSchema = {
+    docUrl,
+    absoluteCurrentWorkingDirectory,
+};
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const inputSchemaZodObject = z.object({
+    ...inputSchema,
+});
+const toolName = 'fetch-doc';
+export class DocFetchTool extends Tool {
+    constructor(mcpServer) {
+        super(mcpServer);
+    }
+    async handler({ docUrl, absoluteCurrentWorkingDirectory, }) {
+        setupHubSpotConfig(absoluteCurrentWorkingDirectory);
+        await trackToolUsage(toolName);
+        try {
+            // Append .md extension to the URL
+            const markdownUrl = `${docUrl}.md`;
+            const response = await http.get({
+                url: markdownUrl,
+            });
+            const content = response.data;
+            if (!content || content.trim().length === 0) {
+                return formatTextContents('Document is empty or contains no content.');
+            }
+            return formatTextContents(content);
+        }
+        catch (error) {
+            if (isHubSpotHttpError(error)) {
+                return formatTextContents(error.toString());
+            }
+            const errorMessage = `Error fetching documentation: ${getErrorMessage(error)}`;
+            return formatTextContents(errorMessage);
+        }
+    }
+    register() {
+        return this.mcpServer.registerTool(toolName, {
+            title: 'Fetch HubSpot Developer Documentation (single file)',
+            description: 'Always use this immediately after `search-docs` and before creating a plan, writing code, or answering technical questions. This tool retrieves the full, authoritative content of a HubSpot Developer Documentation page from its URL, ensuring responses are accurate, up-to-date, and grounded in the official docs.',
+            inputSchema,
+            annotations: {
+                readOnlyHint: true,
+                openWorldHint: true,
+            },
+        }, this.handler);
+    }
+}

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

@@ -0,0 +1,23 @@
+import { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+import z from 'zod';
+import { TextContentResponse, Tool } from '../../types.js';
+declare const inputSchemaZodObject: z.ZodObject<{
+    absoluteCurrentWorkingDirectory: z.ZodString;
+    docsSearchQuery: z.ZodString;
+}, z.z.core.$strip>;
+export interface DocsSearchResponse {
+    results: {
+        title: string;
+        content: string;
+        description: string;
+        url: string;
+        score: number;
+    }[];
+}
+type InputSchemaType = z.infer<typeof inputSchemaZodObject>;
+export declare class DocsSearchTool extends Tool<InputSchemaType> {
+    constructor(mcpServer: McpServer);
+    handler({ docsSearchQuery, absoluteCurrentWorkingDirectory, }: InputSchemaType): Promise<TextContentResponse>;
+    register(): RegisteredTool;
+}
+export {};

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

@@ -0,0 +1,69 @@
+import { http } from '@hubspot/local-dev-lib/http';
+import z from 'zod';
+import { Tool } from '../../types.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 { getErrorMessage } from '../../../lib/errorHandlers/index.js';
+const inputSchema = {
+    absoluteCurrentWorkingDirectory,
+    docsSearchQuery,
+};
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const inputSchemaZodObject = z.object({
+    ...inputSchema,
+});
+const toolName = 'search-docs';
+export class DocsSearchTool extends Tool {
+    constructor(mcpServer) {
+        super(mcpServer);
+    }
+    async handler({ docsSearchQuery, 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 response = await http.post(accountId, {
+                url: 'dev/docs/llms/v1/docs-search',
+                data: {
+                    query: docsSearchQuery,
+                },
+            });
+            const results = response.data.results;
+            if (!results || results.length === 0) {
+                return formatTextContents('No documentation found for your query.');
+            }
+            const formattedResults = results
+                .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}`;
+            return formatTextContents(successMessage);
+        }
+        catch (error) {
+            if (isHubSpotHttpError(error)) {
+                // Handle different status codes
+                return formatTextContents(error.toString());
+            }
+            const errorMessage = `Error searching documentation: ${getErrorMessage(error)}`;
+            return formatTextContents(errorMessage);
+        }
+    }
+    register() {
+        return this.mcpServer.registerTool(toolName, {
+            title: 'Search HubSpot Developer Documentation',
+            description: 'Use this first whenever you need details about HubSpot APIs, SDKs, integrations, or developer platform features. This searches the official HubSpot Developer Documentation and returns the most relevant pages, each with a URL for use in `fetch-doc`. Always follow this with a fetch to get the full, authoritative content before making plans or writing answers.',
+            inputSchema,
+            annotations: {
+                readOnlyHint: true,
+                openWorldHint: true,
+            },
+        }, this.handler);
+    }
+}

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

@@ -0,0 +1,16 @@
+import { TextContentResponse, Tool } from '../../types.js';
+import { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+declare const inputSchemaZodObject: z.ZodObject<{
+    absoluteCurrentWorkingDirectory: 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>;
+    register(): RegisteredTool;
+}
+export {};

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

@@ -0,0 +1,73 @@
+import { Tool } from '../../types.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 { setupHubSpotConfig } from '../../utils/config.js';
+import { getErrorMessage } from '../../../lib/errorHandlers/index.js';
+const inputSchema = {
+    absoluteCurrentWorkingDirectory,
+    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.'),
+    startDate: z
+        .string()
+        .describe('Start date for the usage patterns query in YYYY-MM-DD format (e.g., 2025-01-01).')
+        .optional(),
+    endDate: z
+        .string()
+        .describe('End date for the usage patterns query in YYYY-MM-DD format (e.g., 2025-12-31).')
+        .optional(),
+};
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const inputSchemaZodObject = z.object({ ...inputSchema });
+const toolName = 'get-api-usage-patterns-by-app-id';
+export class GetApiUsagePatternsByAppIdTool extends Tool {
+    constructor(mcpServer) {
+        super(mcpServer);
+    }
+    async handler({ appId, startDate, endDate, absoluteCurrentWorkingDirectory, }) {
+        setupHubSpotConfig(absoluteCurrentWorkingDirectory);
+        await trackToolUsage(toolName);
+        try {
+            // Get account ID from CLI config
+            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);
+            }
+            const response = await http.get(accountId, {
+                url: `app/feature/utilization/public/v3/insights/app/${appId}/usage-patterns`,
+                params: {
+                    ...(startDate && { startDate }),
+                    ...(endDate && { endDate }),
+                },
+            });
+            // Format the response for display
+            const { data } = response;
+            const formattedResult = JSON.stringify(data, null, 2);
+            return formatTextContents(formattedResult);
+        }
+        catch (error) {
+            if (isHubSpotHttpError(error)) {
+                // Handle HubSpot-specific HTTP errors
+                return formatTextContents(error.toString());
+            }
+            return formatTextContents(getErrorMessage(error));
+        }
+    }
+    register() {
+        return this.mcpServer.registerTool(toolName, {
+            title: 'Get API Usage Patterns by App ID',
+            description: 'Retrieves detailed API usage pattern analytics for a specific HubSpot app. Requires an appId (string) to identify the target app. Optionally accepts startDate and endDate parameters in YYYY-MM-DD format to filter results within a specific time range. Returns patternSummaries object containing usage statistics including portalPercentage (percentage of portals using this pattern) and numOfPortals (total count of portals) for different usage patterns. This data helps analyze how the app is being used across different HubSpot portals and can inform optimization decisions.',
+            inputSchema,
+            annotations: {
+                readOnlyHint: true,
+                openWorldHint: true,
+            },
+        }, this.handler);
+    }
+}

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

@@ -0,0 +1,13 @@
+import { TextContentResponse, Tool } from '../../types.js';
+import { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+declare const inputSchemaZodObject: z.ZodObject<{
+    absoluteCurrentWorkingDirectory: 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>;
+    register(): RegisteredTool;
+}
+export {};

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

@@ -0,0 +1,56 @@
+import { Tool } from '../../types.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 { setupHubSpotConfig } from '../../utils/config.js';
+import { getErrorMessage } from '../../../lib/errorHandlers/index.js';
+const inputSchema = { absoluteCurrentWorkingDirectory };
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const inputSchemaZodObject = z.object({ ...inputSchema });
+const toolName = 'get-apps-info';
+export class GetApplicationInfoTool extends Tool {
+    constructor(mcpServer) {
+        super(mcpServer);
+    }
+    async handler({ absoluteCurrentWorkingDirectory, }) {
+        setupHubSpotConfig(absoluteCurrentWorkingDirectory);
+        await trackToolUsage(toolName);
+        try {
+            // Get account ID from CLI config
+            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);
+            }
+            const response = await http.get(accountId, {
+                url: `app/feature/utilization/public/v3/insights/apps`,
+            });
+            // Format the response for display
+            const { data } = response;
+            const formattedResult = JSON.stringify(data, null, 2);
+            return formatTextContents(formattedResult);
+        }
+        catch (error) {
+            if (isHubSpotHttpError(error)) {
+                // Handle HubSpot-specific HTTP errors
+                return formatTextContents(error.toString());
+            }
+            return formatTextContents(getErrorMessage(error));
+        }
+    }
+    register() {
+        return this.mcpServer.registerTool(toolName, {
+            title: 'Get Apps Information',
+            description: 'Retrieves a list of all HubSpot apps available in the current account. Returns an array of apps, where each app contains an appId (numeric identifier) and appName (string). This information is useful for identifying available apps before using other tools that require specific app IDs, such as getting API usage patterns. No input parameters are required - this tool fetches all apps from the HubSpot Insights API.',
+            inputSchema,
+            annotations: {
+                readOnlyHint: true,
+                openWorldHint: true,
+            },
+        }, this.handler);
+    }
+}

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

@@ -0,0 +1,21 @@
+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.ZodOptional<z.ZodEnum<{
+        ERROR: "ERROR";
+        WARN: "WARN";
+        INFO: "INFO";
+        ALL: "ALL";
+    }>>;
+}, z.core.$strip>;
+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,124 @@
+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'])
+        .describe('Filter logs by level. ERROR: Show only errors, WARN: Show only warnings, INFO: Show only info, ALL: Show all logs. Defaults to ALL if not specified.')
+        .optional(),
+};
+// 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 resolvedLogLevel = logLevel || 'ALL';
+            const filteredLogs = filterLogsByLevel(allLogs, resolvedLogLevel);
+            let output;
+            if (filteredLogs.length === 0) {
+                output = `No ${resolvedLogLevel} level logs found for build #${buildId} in '${projectName}'.\nShowing all logs instead:\n\n${formatLogs(allLogs)}`;
+            }
+            else {
+                output = `Logs for build #${buildId} in '${projectName}' (${resolvedLogLevel} 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,16 @@
+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.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+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,165 @@
+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()
+        .describe('Number of recent builds to fetch when buildId is not specified. Defaults to 3 if not specified.')
+        .optional(),
+};
+// 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: limit || 3,
+                });
+                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

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