@hubspot/cli 8.1.0-beta.0 → 8.1.0-experimental.0

package/lib/ui/accountTable.js

@@ -0,0 +1,67 @@
+import { HUBSPOT_ACCOUNT_TYPES, HUBSPOT_ACCOUNT_TYPE_STRINGS, } from '@hubspot/local-dev-lib/constants/config';
+import { isSandbox, isDeveloperTestAccount } from '../accountTypes.js';
+import { getAllConfigAccounts } from '@hubspot/local-dev-lib/config';
+import { commands } from '../../lang/en.js';
+import { renderTable } from '../../ui/render.js';
+import { uiLogger } from './logger.js';
+export function sortAndMapAccounts(accounts) {
+    const mappedAccountData = {};
+    // Standard and app developer accounts
+    accounts
+        .filter(p => p.accountType &&
+        (p.accountType === HUBSPOT_ACCOUNT_TYPES.STANDARD ||
+            p.accountType === HUBSPOT_ACCOUNT_TYPES.APP_DEVELOPER))
+        .forEach(account => {
+        mappedAccountData[account.accountId] = [account];
+    });
+    // Non-standard accounts (sandbox, developer test account)
+    accounts
+        .filter(p => p.accountType && (isSandbox(p) || isDeveloperTestAccount(p)))
+        .forEach(p => {
+        if (p.parentAccountId) {
+            mappedAccountData[p.parentAccountId] = [
+                ...(mappedAccountData[p.parentAccountId] || []),
+                p,
+            ];
+        }
+        else {
+            mappedAccountData[p.accountId] = [p];
+        }
+    });
+    return mappedAccountData;
+}
+export function getAccountData(mappedAccountData) {
+    const accountData = [];
+    Object.entries(mappedAccountData).forEach(([key, set]) => {
+        const hasParentAccount = set.filter(p => p.accountId === parseInt(key, 10))[0];
+        set.forEach(account => {
+            let name = `${account.name} [${HUBSPOT_ACCOUNT_TYPE_STRINGS[account.accountType]}]`;
+            if (isSandbox(account)) {
+                if (hasParentAccount && set.length > 1) {
+                    name = `↳ ${name}`;
+                }
+            }
+            else if (isDeveloperTestAccount(account)) {
+                if (hasParentAccount && set.length > 1) {
+                    name = `↳ ${name}`;
+                }
+            }
+            accountData.push([name, String(account.accountId), account.authType]);
+        });
+    });
+    return accountData;
+}
+export function renderAccountTable(showAllLabel = false) {
+    const accountsList = getAllConfigAccounts();
+    const mappedAccountData = sortAndMapAccounts(accountsList);
+    const accountData = getAccountData(mappedAccountData);
+    const tableHeader = [
+        commands.account.subcommands.list.labels.name,
+        commands.account.subcommands.list.labels.accountId,
+        commands.account.subcommands.list.labels.authType,
+    ];
+    uiLogger.log(showAllLabel
+        ? commands.account.subcommands.list.allAccounts
+        : commands.account.subcommands.list.accounts);
+    renderTable(tableHeader, accountData, true);
+}

package/lib/ui/spinniesUtils.d.ts

@@ -28,5 +28,4 @@ export declare function breakText(text: string, prefixLength: number): string;
 export declare function getLinesLength(text: string, prefixLength: number): number[];
 export declare function writeStream(stream: NodeJS.WriteStream, output: string, rawLines: number[]): void;
 export declare function cleanStream(stream: NodeJS.WriteStream, rawLines: number[]): void;
-export declare function terminalSupportsUnicode(): boolean;
 export {};

package/lib/ui/spinniesUtils.js

@@ -9,6 +9,8 @@ The above copyright notice and this permission notice shall be included in all c
 **/
 import readline from 'readline';
 import stripAnsi from 'strip-ansi';
+import { isUnicodeSupported } from '@hubspot/local-dev-lib/isUnicodeSupported';
+import { getSymbols } from '@hubspot/local-dev-lib/logger';
 export const VALID_STATUSES = [
     'succeed',
     'fail',
@@ -64,7 +66,7 @@ export function purgeSpinnersOptions({ spinner, disableSpins, ...others }) {
     return { ...colors, ...prefixes, ...disableSpinsOption, spinner };
 }
 function turnToValidSpinner(spinner = {}) {
-    const platformSpinner = terminalSupportsUnicode()
+    const platformSpinner = isUnicodeSupported()
         ? SPINNERS.dots
         : SPINNERS.dashes;
     if (typeof spinner !== 'object') {
@@ -101,14 +103,9 @@ export function colorOptions({ color, succeedColor, failColor, spinnerColor, })
     return colors;
 }
 export function prefixOptions({ succeedPrefix, failPrefix, }) {
-    if (terminalSupportsUnicode()) {
-        succeedPrefix = succeedPrefix || '✓';
-        failPrefix = failPrefix || '✖';
-    }
-    else {
-        succeedPrefix = succeedPrefix || '√';
-        failPrefix = failPrefix || '×';
-    }
+    const symbols = getSymbols();
+    succeedPrefix = succeedPrefix || symbols.success;
+    failPrefix = failPrefix || symbols.error;
     return { succeedPrefix, failPrefix };
 }
 export function breakText(text, prefixLength) {
@@ -142,10 +139,3 @@ export function cleanStream(stream, rawLines) {
     readline.clearScreenDown(stream);
     readline.moveCursor(stream, 0, -rawLines.length);
 }
-export function terminalSupportsUnicode() {
-    // The default command prompt and powershell in Windows do not support Unicode characters.
-    // However, the VSCode integrated terminal and the Windows Terminal both do.
-    return (process.platform !== 'win32' ||
-        process.env.TERM_PROGRAM === 'vscode' ||
-        !!process.env.WT_SESSION);
-}

package/lib/usageTracking.d.ts

@@ -1,4 +1,4 @@
-type Meta = {
+export type UsageTrackingMeta = {
     action?: string;
     os?: string;
     nodeVersion?: string;
@@ -24,9 +24,8 @@ export declare function getNodeVersionData(): {
     nodeMajorVersion: string;
 };
 export declare function getPlatform(): string;
-export declare function trackCommandUsage(command: string, meta?: Meta, accountId?: number): Promise<void>;
+export declare function trackCommandUsage(command: string, meta?: UsageTrackingMeta, accountId?: number): Promise<void>;
 export declare function trackHelpUsage(command: string): Promise<void>;
 export declare function trackConvertFieldsUsage(command: string): Promise<void>;
 export declare function trackAuthAction(command: string, authType: string, step: string, accountId?: number): Promise<void>;
-export declare function trackCommandMetadataUsage(command: string, meta?: Meta, accountId?: number): Promise<void>;
-export {};
+export declare function trackCommandMetadataUsage(command: string, meta?: UsageTrackingMeta, accountId?: number): Promise<void>;

package/lib/usageTracking.js

@@ -44,11 +44,14 @@ export async function trackCommandUsage(command, meta = {}, accountId) {
     uiLogger.debug(`Attempting to track usage of "${command}" command`);
     let authType = 'unknown';
     if (accountId) {
-        const accountConfig = getConfigAccountById(accountId);
-        authType =
-            accountConfig && accountConfig.authType
-                ? accountConfig.authType
-                : API_KEY_AUTH_METHOD.value;
+        try {
+            const accountConfig = getConfigAccountById(accountId);
+            authType =
+                accountConfig && accountConfig.authType
+                    ? accountConfig.authType
+                    : API_KEY_AUTH_METHOD.value;
+        }
+        catch (e) { }
     }
     return trackCliInteraction({
         action: 'cli-command',
@@ -159,7 +162,7 @@ async function trackCliInteraction({ action, accountId, command, authType, meta
         }
         try {
             uiLogger.debug('Sent usage tracking command event:', usageTrackingEvent);
-            return trackUsage('cli-interaction', EventClass.INTERACTION, usageTrackingEvent, accountId);
+            await trackUsage('cli-interaction', EventClass.INTERACTION, usageTrackingEvent, accountId);
         }
         catch (error) {
             debugError(error);

package/lib/yargs/makeYargsBuilder.d.ts

@@ -0,0 +1,13 @@
+import { Argv } from 'yargs';
+export declare function makeYargsBuilder<T>(callback: (yargs: Argv) => Argv<T>, command: string | string[], describe?: string, options?: {
+    useGlobalOptions?: boolean;
+    useAccountOptions?: boolean;
+    useConfigOptions?: boolean;
+    useEnvironmentOptions?: boolean;
+    useTestingOptions?: boolean;
+    useCmsPublishModeOptions?: boolean | {
+        read?: boolean;
+        write?: boolean;
+    };
+    useJSONOutputOptions?: boolean;
+}): (yargs: Argv) => Promise<Argv<T>>;

package/lib/yargs/makeYargsBuilder.js

@@ -0,0 +1,33 @@
+import { addCustomHelpOutput, addTestingOptions, addAccountOptions, addConfigOptions, addGlobalOptions, addUseEnvironmentOptions, addCmsPublishModeOptions, addJSONOutputOptions, } from '../commonOpts.js';
+export function makeYargsBuilder(callback, command, describe, options = {}) {
+    return async function (yargs) {
+        if (options.useGlobalOptions) {
+            addGlobalOptions(yargs);
+        }
+        if (options.useAccountOptions) {
+            addAccountOptions(yargs);
+        }
+        if (options.useConfigOptions) {
+            addConfigOptions(yargs);
+        }
+        if (options.useEnvironmentOptions) {
+            addUseEnvironmentOptions(yargs);
+        }
+        if (options.useTestingOptions) {
+            addTestingOptions(yargs);
+        }
+        if (options.useJSONOutputOptions) {
+            addJSONOutputOptions(yargs);
+        }
+        if (options.useCmsPublishModeOptions) {
+            const opts = typeof options.useCmsPublishModeOptions === 'object'
+                ? options.useCmsPublishModeOptions
+                : { write: true };
+            addCmsPublishModeOptions(yargs, opts);
+        }
+        const result = callback(yargs);
+        // Must go last to pick up available options
+        await addCustomHelpOutput(result, command, describe);
+        return result;
+    };
+}

package/lib/yargs/makeYargsHandlerWithUsageTracking.d.ts

@@ -0,0 +1,3 @@
+import { ArgumentsCamelCase } from 'yargs';
+import { CommonArgs } from '../../types/Yargs.js';
+export declare function makeYargsHandlerWithUsageTracking<T extends CommonArgs>(trackingName: string, handler: (args: ArgumentsCamelCase<T>) => Promise<void>): (args: ArgumentsCamelCase<T>) => Promise<void>;

package/lib/yargs/makeYargsHandlerWithUsageTracking.js

@@ -0,0 +1,95 @@
+import { getConfig } from '@hubspot/local-dev-lib/config';
+import { getStateValue, setStateValue, } from '@hubspot/local-dev-lib/config/state';
+import { STATE_FLAGS } from '@hubspot/local-dev-lib/constants/config';
+import { trackCommandUsage as _trackCommandUsage } from '../usageTracking.js';
+import { pkg } from '../jsonLoader.js';
+import { uiLogger } from '../ui/logger.js';
+import { lib } from '../../lang/en.js';
+import { EXIT_CODES } from '../enums/exitCodes.js';
+import { isPromptExitError } from '../errors/PromptExitError.js';
+import { debugError } from '../errorHandlers/index.js';
+function logUsageTrackingMessage(isJsonOutput) {
+    if (isJsonOutput) {
+        return;
+    }
+    try {
+        const config = getConfig();
+        if (config?.allowUsageTracking !== true) {
+            return;
+        }
+        const lastShownVersion = getStateValue(STATE_FLAGS.USAGE_TRACKING_MESSAGE_LAST_SHOW_VERSION);
+        if (lastShownVersion === pkg.version) {
+            return;
+        }
+        setStateValue(STATE_FLAGS.USAGE_TRACKING_MESSAGE_LAST_SHOW_VERSION, pkg.version);
+        uiLogger.info(lib.usageTracking.transparencyMessage);
+    }
+    catch (_e) {
+        return;
+    }
+}
+export function makeYargsHandlerWithUsageTracking(trackingName, handler) {
+    return async (args) => {
+        const meta = {};
+        let trackingFired = false;
+        const trackingArgs = args;
+        const addUsageMetadata = (newMeta) => {
+            Object.assign(meta, newMeta);
+        };
+        trackingArgs.addUsageMetadata = addUsageMetadata;
+        const trackCommandUsage = async (successful) => {
+            if (trackingFired) {
+                return;
+            }
+            trackingFired = true;
+            try {
+                const { accountId: overrideAccountId, ...trackingMeta } = meta;
+                trackingMeta.successful = successful;
+                await _trackCommandUsage(trackingName, trackingMeta, overrideAccountId ?? args.derivedAccountId);
+            }
+            catch (_e) { }
+        };
+        const onForcedExit = () => {
+            process.exit(EXIT_CODES.SUCCESS);
+        };
+        const onSigint = async () => {
+            process.removeListener('SIGINT', onSigint);
+            process.on('SIGINT', onForcedExit);
+            try {
+                await trackCommandUsage(false);
+            }
+            catch (_e) { }
+            process.removeListener('SIGINT', onForcedExit);
+            process.exit(EXIT_CODES.SUCCESS);
+        };
+        process.on('SIGINT', onSigint);
+        const trackCommandUsageAndRemoveListeners = async (successful) => {
+            await trackCommandUsage(successful);
+            process.removeListener('SIGINT', onSigint);
+            process.removeListener('SIGINT', onForcedExit);
+        };
+        trackingArgs.exit = async (code) => {
+            await trackCommandUsageAndRemoveListeners(code !== EXIT_CODES.ERROR);
+            return process.exit(code);
+        };
+        const jsonArgs = args;
+        logUsageTrackingMessage(Boolean(jsonArgs.json || jsonArgs.formatOutputAsJson));
+        try {
+            await handler(trackingArgs);
+        }
+        catch (e) {
+            const isSuccessfulPromptExit = isPromptExitError(e)
+                ? e.exitCode !== EXIT_CODES.ERROR
+                : false;
+            await trackCommandUsageAndRemoveListeners(isSuccessfulPromptExit);
+            if (isPromptExitError(e)) {
+                return process.exit(e.exitCode);
+            }
+            else {
+                debugError(e);
+                return process.exit(EXIT_CODES.ERROR);
+            }
+        }
+        await trackCommandUsageAndRemoveListeners(true);
+    };
+}

package/lib/yargs/parseYargsOrExit.d.ts

@@ -0,0 +1,4 @@
+import { ArgumentsCamelCase, Argv } from 'yargs';
+type YargsFailureHandler<T> = (message: string | null, error: unknown, parser: Argv<T>) => never;
+export declare function parseYargsOrExit<T>(parser: Argv<T>, handleFailure: YargsFailureHandler<T>): Promise<ArgumentsCamelCase<T>>;
+export {};

package/lib/yargs/parseYargsOrExit.js

@@ -0,0 +1,25 @@
+function getYargsErrorMessage(error) {
+    return error instanceof Error && error.name === 'YError' ? error.message : '';
+}
+function getYargsFailureMessage(message, error) {
+    if (message) {
+        return message;
+    }
+    return getYargsErrorMessage(error) || message;
+}
+export async function parseYargsOrExit(parser, handleFailure) {
+    let failureHandled = false;
+    const parserWithFailureHandler = parser.fail((message, error, yargs) => {
+        failureHandled = true;
+        return handleFailure(getYargsFailureMessage(message, error), error, yargs);
+    });
+    try {
+        return await parserWithFailureHandler.parseAsync();
+    }
+    catch (error) {
+        if (failureHandled) {
+            throw error;
+        }
+        return handleFailure(getYargsErrorMessage(error), error, parserWithFailureHandler);
+    }
+}

package/lib/yargs/strictEnforceBoolean.d.ts

@@ -0,0 +1 @@
+export declare function strictEnforceBoolean(rawArgs: string[], booleanOptions: string[]): boolean;

package/lib/yargs/strictEnforceBoolean.js

@@ -0,0 +1,13 @@
+import { commands } from '../../lang/en.js';
+export function strictEnforceBoolean(rawArgs, booleanOptions) {
+    for (const option of booleanOptions) {
+        const argIndex = rawArgs.findIndex(arg => arg.startsWith(`--${option}=`));
+        if (argIndex !== -1) {
+            const value = rawArgs[argIndex].split('=')[1];
+            if (value && !['true', 'false'].includes(value.toLowerCase())) {
+                throw new Error(commands.config.subcommands.set.errors.invalidBoolean(option, value));
+            }
+        }
+    }
+    return true;
+}

package/lib/yargsUtils.d.ts

@@ -1,16 +1,3 @@
-import { Argv } from 'yargs';
-import { hasFlag } from './utils/hasFlag.js';
-export { hasFlag };
-export declare function makeYargsBuilder<T>(callback: (yargs: Argv) => Argv<T>, command: string | string[], describe?: string, options?: {
-    useGlobalOptions?: boolean;
-    useAccountOptions?: boolean;
-    useConfigOptions?: boolean;
-    useEnvironmentOptions?: boolean;
-    useTestingOptions?: boolean;
-    useCmsPublishModeOptions?: boolean | {
-        read?: boolean;
-        write?: boolean;
-    };
-    useJSONOutputOptions?: boolean;
-}): (yargs: Argv) => Promise<Argv<T>>;
-export declare function strictEnforceBoolean(rawArgs: string[], booleanOptions: string[]): boolean;
+export { hasFlag } from './utils/hasFlag.js';
+export { makeYargsBuilder } from './yargs/makeYargsBuilder.js';
+export { strictEnforceBoolean } from './yargs/strictEnforceBoolean.js';

package/lib/yargsUtils.js

@@ -1,49 +1,4 @@
-import { addCustomHelpOutput, addTestingOptions, addAccountOptions, addConfigOptions, addGlobalOptions, addUseEnvironmentOptions, addCmsPublishModeOptions, addJSONOutputOptions, } from './commonOpts.js';
-import { hasFlag } from './utils/hasFlag.js';
-import { commands } from '../lang/en.js';
 // Re-export for backwards compatibility
-export { hasFlag };
-export function makeYargsBuilder(callback, command, describe, options = {}) {
-    return async function (yargs) {
-        if (options.useGlobalOptions) {
-            addGlobalOptions(yargs);
-        }
-        if (options.useAccountOptions) {
-            addAccountOptions(yargs);
-        }
-        if (options.useConfigOptions) {
-            addConfigOptions(yargs);
-        }
-        if (options.useEnvironmentOptions) {
-            addUseEnvironmentOptions(yargs);
-        }
-        if (options.useTestingOptions) {
-            addTestingOptions(yargs);
-        }
-        if (options.useJSONOutputOptions) {
-            addJSONOutputOptions(yargs);
-        }
-        if (options.useCmsPublishModeOptions) {
-            const opts = typeof options.useCmsPublishModeOptions === 'object'
-                ? options.useCmsPublishModeOptions
-                : { write: true };
-            addCmsPublishModeOptions(yargs, opts);
-        }
-        const result = callback(yargs);
-        // Must go last to pick up available options
-        await addCustomHelpOutput(result, command, describe);
-        return result;
-    };
-}
-export function strictEnforceBoolean(rawArgs, booleanOptions) {
-    for (const option of booleanOptions) {
-        const argIndex = rawArgs.findIndex(arg => arg.startsWith(`--${option}=`));
-        if (argIndex !== -1) {
-            const value = rawArgs[argIndex].split('=')[1];
-            if (value && !['true', 'false'].includes(value.toLowerCase())) {
-                throw new Error(commands.config.subcommands.set.errors.invalidBoolean(option, value));
-            }
-        }
-    }
-    return true;
-}
+export { hasFlag } from './utils/hasFlag.js';
+export { makeYargsBuilder } from './yargs/makeYargsBuilder.js';
+export { strictEnforceBoolean } from './yargs/strictEnforceBoolean.js';

package/mcp-server/Tool.d.ts

@@ -0,0 +1,15 @@
+import { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { McpLogger } from './utils/logger.js';
+import { TextContentResponse } from './types.js';
+export declare class Tool<InputSchema> {
+    protected mcpServer: McpServer;
+    protected logger: McpLogger;
+    protected toolName: string;
+    constructor(mcpServer: McpServer, logger: McpLogger, toolName: string);
+    register(): RegisteredTool;
+    handler(input: InputSchema): TextContentResponse | Promise<TextContentResponse>;
+    protected getTrackingMeta(input: InputSchema): {
+        [key: string]: string;
+    } | undefined;
+    protected wrappedHandler(input: InputSchema): Promise<TextContentResponse>;
+}

package/mcp-server/Tool.js

@@ -0,0 +1,53 @@
+import { formatTextContents } from './utils/content.js';
+import { getErrorMessage } from '../lib/errorHandlers/index.js';
+import { trackToolUsage } from './utils/toolUsageTracking.js';
+export class Tool {
+    mcpServer;
+    logger;
+    toolName;
+    constructor(mcpServer, logger, toolName) {
+        this.mcpServer = mcpServer;
+        this.logger = logger;
+        this.toolName = toolName;
+    }
+    register() {
+        throw new Error('Must implement register');
+    }
+    handler(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    input) {
+        throw new Error('Must implement handler');
+    }
+    getTrackingMeta(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    input) {
+        return undefined;
+    }
+    async wrappedHandler(input) {
+        const startTime = Date.now();
+        try {
+            // `input` is logged unredacted. Tool input schemas MUST NOT include
+            // credentials or other sensitive values, since MCP clients (Claude
+            // Desktop, Inspector, etc.) will display these logs.
+            this.logger.debug(this.toolName, {
+                message: 'Tool invoked',
+                args: input,
+            });
+            await trackToolUsage(this.toolName, this.getTrackingMeta(input));
+            const result = await this.handler(input);
+            this.logger.debug(this.toolName, {
+                message: 'Tool completed',
+                durationMs: Date.now() - startTime,
+            });
+            return result;
+        }
+        catch (error) {
+            this.logger.error(this.toolName, {
+                message: 'Tool failed',
+                error: error instanceof Error ? error.message : String(error),
+                durationMs: Date.now() - startTime,
+            });
+            return formatTextContents(getErrorMessage(error));
+        }
+    }
+}

package/mcp-server/server.js

@@ -1,13 +1,53 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { registerProjectTools, registerCmsTools } from './tools/index.js';
+import { McpLogger } from './utils/logger.js';
+const instructions = `
+This server exposes the HubSpot CLI (\`hs\`) for local development of HubSpot
+projects, apps, and CMS assets. Prefer these tools over running \`hs\`,
+\`npx hs\`, or HubSpot HTTP APIs directly via shell — they handle config
+loading, auth, platform-version flags, and structured output for you.
+
+WHEN TO USE THIS SERVER
+- The user is working in a HubSpot project directory (has an hsproject.json
+  or *-hsmeta.json files), or wants to scaffold one.
+- The user asks about HubSpot apps, CMS modules/templates/serverless
+  functions, project builds, deploys, or developer test accounts.
+- The user asks a HubSpot platform/API question — answer it from the docs
+  via \`search-docs\` + \`fetch-doc\` rather than from prior knowledge.
+
+REQUIRED WORKFLOWS
+1. Documentation lookup: always call \`search-docs\` first, then
+   \`fetch-doc\` on the most relevant result(s) before planning, writing
+   code, or answering platform/API questions. Do not answer from memory.
+2. Locating a HubSpot project: when the current working directory is not
+   a HubSpot project (no \`hsproject.json\`) or you need to determine
+   whether a directory contains one, call \`find-projects\` before
+   running any tool that requires a project path.
+3. Editing \`*-hsmeta.json\`: call \`get-feature-config-schema\` for that
+   feature type first to learn the allowed fields and values.
+4. Debugging a failed build: start with \`get-build-status\` to surface
+   error messages, and only reach for \`get-build-logs\` for deeper
+   troubleshooting or warnings.
+5. Reading serverless function logs: call \`list-cms-serverless-functions\`
+   first to discover the endpoint path, then
+   \`get-cms-serverless-function-logs\`.
+6. App analytics: call \`get-apps-info\` to discover \`appId\` values
+   before \`get-api-usage-patterns-by-app-id\`.
+
+OUTPUT
+Tool results contain the relevant \`hs\` stdout/stderr or structured data.
+Surface error text from results to the user verbatim when troubleshooting,
+rather than paraphrasing.
+`.trim();
 const server = new McpServer({
     name: 'HubSpot CLI MCP Server',
     version: '0.0.1',
     description: 'Helps perform tasks for local development of HubSpot projects.',
-});
-registerProjectTools(server);
-registerCmsTools(server);
+}, { capabilities: { logging: {} }, instructions });
+const logger = new McpLogger(server);
+registerProjectTools(server, logger);
+registerCmsTools(server, logger);
 // Start receiving messages on stdin and sending messages on stdout
 const transport = new StdioServerTransport();
 server.connect(transport);

package/mcp-server/tools/cms/HsCreateFunctionTool.d.ts

@@ -1,5 +1,7 @@
-import { TextContentResponse, Tool } from '../../types.js';
+import { TextContentResponse } from '../../types.js';
+import { Tool } from '../../Tool.js';
 import { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { McpLogger } from '../../utils/logger.js';
 import { z } from 'zod';
 declare const inputSchemaZodObject: z.ZodObject<{
     absoluteCurrentWorkingDirectory: z.ZodString;
@@ -17,7 +19,7 @@ declare const inputSchemaZodObject: z.ZodObject<{
 }, z.core.$strip>;
 export type HsCreateFunctionInputSchema = z.infer<typeof inputSchemaZodObject>;
 export declare class HsCreateFunctionTool extends Tool<HsCreateFunctionInputSchema> {
-    constructor(mcpServer: McpServer);
+    constructor(mcpServer: McpServer, logger: McpLogger);
     handler({ dest, functionsFolder, filename, endpointMethod, endpointPath, absoluteCurrentWorkingDirectory, }: HsCreateFunctionInputSchema): Promise<TextContentResponse>;
     register(): RegisteredTool;
 }

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

@@ -1,9 +1,8 @@
-import { Tool } from '../../types.js';
+import { Tool } from '../../Tool.js';
 import { z } from 'zod';
 import { absoluteCurrentWorkingDirectory } from '../project/constants.js';
-import { runCommandInDir } from '../../utils/project.js';
+import { runCommandInDir } from '../../utils/command.js';
 import { formatTextContents, formatTextContent } from '../../utils/content.js';
-import { trackToolUsage } from '../../utils/toolUsageTracking.js';
 import { addFlag } from '../../utils/command.js';
 import { HTTP_METHODS } from '../../../types/Cms.js';
 import { setupHubSpotConfig } from '../../utils/config.js';
@@ -35,12 +34,11 @@ const inputSchema = {
 const inputSchemaZodObject = z.object({ ...inputSchema });
 const toolName = 'create-cms-function';
 export class HsCreateFunctionTool extends Tool {
-    constructor(mcpServer) {
-        super(mcpServer);
+    constructor(mcpServer, logger) {
+        super(mcpServer, logger, toolName);
     }
     async handler({ dest, functionsFolder, filename, endpointMethod, endpointPath, absoluteCurrentWorkingDirectory, }) {
         setupHubSpotConfig(absoluteCurrentWorkingDirectory);
-        await trackToolUsage(toolName);
         const content = [];
         // Require functions folder
         if (!functionsFolder) {
@@ -86,6 +84,10 @@ export class HsCreateFunctionTool extends Tool {
             return formatTextContents(stdout, stderr);
         }
         catch (error) {
+            this.logger.debug(toolName, {
+                message: 'Handler caught error',
+                error: error instanceof Error ? error.message : String(error),
+            });
             return formatTextContents(getErrorMessage(error));
         }
     }
@@ -100,6 +102,6 @@ export class HsCreateFunctionTool extends Tool {
                 idempotentHint: false,
                 openWorldHint: false,
             },
-        }, this.handler);
+        }, input => this.wrappedHandler(input));
     }
 }

package/mcp-server/tools/cms/HsCreateModuleTool.d.ts

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