@hubspot/cli 8.10.0 → 8.11.0-beta.0

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

@@ -1,9 +1,9 @@
 import { Tool } from '../../Tool.js';
 import { z } from 'zod';
 import { absoluteCurrentWorkingDirectory } from '../project/constants.js';
-import { addFlag, runCommandInDir } from '../../utils/command.js';
 import { formatTextContent, formatTextContents } from '../../utils/content.js';
 import { CONTENT_TYPES } from '../../../types/Cms.js';
+import { HubSpotCommand } from '../../utils/command.js';
 import { setupHubSpotConfig } from '../../utils/config.js';
 import { getErrorMessage } from '../../../lib/errorHandlers/index.js';
 const inputSchema = {
@@ -52,7 +52,7 @@ export class HsCreateModuleTool extends Tool {
     constructor(mcpServer, logger) {
         super(mcpServer, logger, toolName);
     }
-    async handler({ userSuppliedName, dest, moduleLabel, reactType, contentTypes, global, availableForNewContent, absoluteCurrentWorkingDirectory, }) {
+    async handler({ userSuppliedName, dest, moduleLabel, reactType, contentTypes, global, availableForNewContent, absoluteCurrentWorkingDirectory, }, extra) {
         setupHubSpotConfig(absoluteCurrentWorkingDirectory);
         const content = [];
         // Always require a name
@@ -74,34 +74,28 @@ export class HsCreateModuleTool extends Tool {
             };
         }
         // Build the command
-        let command = 'hs cms module create';
+        const command = new HubSpotCommand('cms module create');
         if (userSuppliedName) {
-            command += ` "${userSuppliedName}"`;
+            command.addArg(userSuppliedName);
         }
         if (dest) {
-            command += ` "${dest}"`;
+            command.addArg(dest);
         }
-        // Add module-specific flags
         if (moduleLabel) {
-            command = addFlag(command, 'module-label', moduleLabel);
+            command.addFlag('module-label', moduleLabel);
         }
         if (reactType !== undefined) {
-            command = addFlag(command, 'react-type', reactType);
-        }
-        if (contentTypes) {
-            command = addFlag(command, 'content-types', contentTypes);
-        }
-        else {
-            command = addFlag(command, 'content-types', 'ANY');
+            command.addFlag('react-type', reactType);
         }
+        command.addFlag('content-types', contentTypes ?? 'ANY');
         if (global !== undefined) {
-            command = addFlag(command, 'global', global);
+            command.addFlag('global', global);
         }
         if (availableForNewContent !== undefined) {
-            command = addFlag(command, 'available-for-new-content', availableForNewContent);
+            command.addFlag('available-for-new-content', availableForNewContent);
         }
         try {
-            const { stdout, stderr } = await runCommandInDir(absoluteCurrentWorkingDirectory, command);
+            const { stdout, stderr } = await this.runCommand(absoluteCurrentWorkingDirectory, command, extra);
             return formatTextContents(stdout, stderr);
         }
         catch (error) {
@@ -123,6 +117,6 @@ export class HsCreateModuleTool extends Tool {
                 idempotentHint: false,
                 openWorldHint: false,
             },
-        }, input => this.wrappedHandler(input));
+        }, (input, extra) => this.wrappedHandler(input, extra));
     }
 }

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

@@ -1,5 +1,5 @@
 import { TextContentResponse } from '../../types.js';
-import { Tool } from '../../Tool.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';
@@ -21,7 +21,7 @@ declare const inputSchemaZodObject: z.ZodObject<{
 export type HsCreateTemplateInputSchema = z.infer<typeof inputSchemaZodObject>;
 export declare class HsCreateTemplateTool extends Tool<HsCreateTemplateInputSchema> {
     constructor(mcpServer: McpServer, logger: McpLogger);
-    handler({ userSuppliedName, dest, templateType, absoluteCurrentWorkingDirectory, }: HsCreateTemplateInputSchema): Promise<TextContentResponse>;
+    handler({ userSuppliedName, dest, templateType, absoluteCurrentWorkingDirectory, }: HsCreateTemplateInputSchema, extra?: ToolExtra): Promise<TextContentResponse>;
     register(): RegisteredTool;
 }
 export {};

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

@@ -1,10 +1,9 @@
 import { Tool } from '../../Tool.js';
 import { z } from 'zod';
 import { absoluteCurrentWorkingDirectory } from '../project/constants.js';
-import { runCommandInDir } from '../../utils/command.js';
 import { formatTextContents, formatTextContent } from '../../utils/content.js';
-import { addFlag } from '../../utils/command.js';
 import { TEMPLATE_TYPES } from '../../../types/Cms.js';
+import { HubSpotCommand } from '../../utils/command.js';
 import { setupHubSpotConfig } from '../../utils/config.js';
 import { getErrorMessage } from '../../../lib/errorHandlers/index.js';
 const inputSchema = {
@@ -29,7 +28,7 @@ export class HsCreateTemplateTool extends Tool {
     constructor(mcpServer, logger) {
         super(mcpServer, logger, toolName);
     }
-    async handler({ userSuppliedName, dest, templateType, absoluteCurrentWorkingDirectory, }) {
+    async handler({ userSuppliedName, dest, templateType, absoluteCurrentWorkingDirectory, }, extra) {
         setupHubSpotConfig(absoluteCurrentWorkingDirectory);
         const content = [];
         // Always require a name
@@ -47,19 +46,18 @@ export class HsCreateTemplateTool extends Tool {
             };
         }
         // Build the command
-        let command = 'hs cms template create';
+        const command = new HubSpotCommand('cms template create');
         if (userSuppliedName) {
-            command += ` "${userSuppliedName}"`;
+            command.addArg(userSuppliedName);
         }
         if (dest) {
-            command += ` "${dest}"`;
+            command.addArg(dest);
         }
-        // Add template type flag
         if (templateType) {
-            command = addFlag(command, 'template-type', templateType);
+            command.addFlag('template-type', templateType);
         }
         try {
-            const { stdout, stderr } = await runCommandInDir(absoluteCurrentWorkingDirectory, command);
+            const { stdout, stderr } = await this.runCommand(absoluteCurrentWorkingDirectory, command, extra);
             return formatTextContents(stdout, stderr);
         }
         catch (error) {
@@ -81,6 +79,6 @@ export class HsCreateTemplateTool extends Tool {
                 idempotentHint: false,
                 openWorldHint: false,
             },
-        }, input => this.wrappedHandler(input));
+        }, (input, extra) => this.wrappedHandler(input, extra));
     }
 }

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

@@ -1,5 +1,5 @@
 import { TextContentResponse } from '../../types.js';
-import { Tool } from '../../Tool.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';
@@ -14,7 +14,7 @@ declare const inputSchemaZodObject: z.ZodObject<{
 export type HsFunctionLogsInputSchema = z.infer<typeof inputSchemaZodObject>;
 export declare class HsFunctionLogsTool extends Tool<HsFunctionLogsInputSchema> {
     constructor(mcpServer: McpServer, logger: McpLogger);
-    handler({ endpoint, account, latest, compact, limit, absoluteCurrentWorkingDirectory, }: HsFunctionLogsInputSchema): Promise<TextContentResponse>;
+    handler({ endpoint, account, latest, compact, limit, absoluteCurrentWorkingDirectory, }: HsFunctionLogsInputSchema, extra?: ToolExtra): Promise<TextContentResponse>;
     register(): RegisteredTool;
 }
 export {};

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

@@ -1,6 +1,6 @@
 import { Tool } from '../../Tool.js';
 import { z } from 'zod';
-import { addFlag, runCommandInDir } from '../../utils/command.js';
+import { HubSpotCommand } from '../../utils/command.js';
 import { absoluteCurrentWorkingDirectory } from '../project/constants.js';
 import { formatTextContents } from '../../utils/content.js';
 import { setupHubSpotConfig } from '../../utils/config.js';
@@ -31,27 +31,27 @@ export class HsFunctionLogsTool extends Tool {
     constructor(mcpServer, logger) {
         super(mcpServer, logger, toolName);
     }
-    async handler({ endpoint, account, latest, compact, limit, absoluteCurrentWorkingDirectory, }) {
+    async handler({ endpoint, account, latest, compact, limit, absoluteCurrentWorkingDirectory, }, extra) {
         setupHubSpotConfig(absoluteCurrentWorkingDirectory);
         // Ensure endpoint doesn't start with '/'
         const normalizedEndpoint = endpoint.startsWith('/')
             ? endpoint.slice(1)
             : endpoint;
-        let command = `hs cms function logs ${normalizedEndpoint}`;
+        const command = new HubSpotCommand(`cms function logs ${normalizedEndpoint}`);
         if (latest) {
-            command = addFlag(command, 'latest', latest);
+            command.addFlag('latest', latest);
         }
         if (compact) {
-            command = addFlag(command, 'compact', compact);
+            command.addFlag('compact', compact);
         }
         if (limit) {
-            command = addFlag(command, 'limit', limit);
+            command.addFlag('limit', limit);
         }
         if (account) {
-            command = addFlag(command, 'account', account);
+            command.addFlag('account', account);
         }
         try {
-            const { stdout, stderr } = await runCommandInDir(absoluteCurrentWorkingDirectory, command);
+            const { stdout, stderr } = await this.runCommand(absoluteCurrentWorkingDirectory, command, extra);
             return formatTextContents(stdout, stderr);
         }
         catch (error) {
@@ -71,6 +71,6 @@ export class HsFunctionLogsTool extends Tool {
                 readOnlyHint: true,
                 openWorldHint: true,
             },
-        }, input => this.wrappedHandler(input));
+        }, (input, extra) => this.wrappedHandler(input, extra));
     }
 }

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

@@ -1,5 +1,5 @@
 import { TextContentResponse } from '../../types.js';
-import { Tool } from '../../Tool.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';
@@ -11,7 +11,7 @@ declare const inputSchemaZodObject: z.ZodObject<{
 export type HsListFunctionsInputSchema = z.infer<typeof inputSchemaZodObject>;
 export declare class HsListFunctionsTool extends Tool<HsListFunctionsInputSchema> {
     constructor(mcpServer: McpServer, logger: McpLogger);
-    handler({ account, json, absoluteCurrentWorkingDirectory, }: HsListFunctionsInputSchema): Promise<TextContentResponse>;
+    handler({ account, json, absoluteCurrentWorkingDirectory, }: HsListFunctionsInputSchema, extra?: ToolExtra): Promise<TextContentResponse>;
     register(): RegisteredTool;
 }
 export {};

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

@@ -1,6 +1,6 @@
 import { Tool } from '../../Tool.js';
 import { z } from 'zod';
-import { addFlag, runCommandInDir } from '../../utils/command.js';
+import { HubSpotCommand } from '../../utils/command.js';
 import { absoluteCurrentWorkingDirectory } from '../project/constants.js';
 import { formatTextContents } from '../../utils/content.js';
 import { setupHubSpotConfig } from '../../utils/config.js';
@@ -23,17 +23,17 @@ export class HsListFunctionsTool extends Tool {
     constructor(mcpServer, logger) {
         super(mcpServer, logger, toolName);
     }
-    async handler({ account, json, absoluteCurrentWorkingDirectory, }) {
+    async handler({ account, json, absoluteCurrentWorkingDirectory, }, extra) {
         setupHubSpotConfig(absoluteCurrentWorkingDirectory);
-        let command = 'hs cms function list';
+        const command = new HubSpotCommand('cms function list');
         if (json) {
-            command += ' --json';
+            command.addFlag('json', true);
         }
         if (account) {
-            command = addFlag(command, 'account', account);
+            command.addFlag('account', account);
         }
         try {
-            const { stdout, stderr } = await runCommandInDir(absoluteCurrentWorkingDirectory, command);
+            const { stdout, stderr } = await this.runCommand(absoluteCurrentWorkingDirectory, command, extra);
             return formatTextContents(stdout, stderr);
         }
         catch (error) {
@@ -60,6 +60,6 @@ export class HsListFunctionsTool extends Tool {
                 readOnlyHint: true,
                 openWorldHint: true,
             },
-        }, input => this.wrappedHandler(input));
+        }, (input, extra) => this.wrappedHandler(input, extra));
     }
 }

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

@@ -1,5 +1,5 @@
 import { TextContentResponse } from '../../types.js';
-import { Tool } from '../../Tool.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';
@@ -11,7 +11,7 @@ declare const inputSchemaZodObject: z.ZodObject<{
 export type HsListInputSchema = z.infer<typeof inputSchemaZodObject>;
 export declare class HsListTool extends Tool<HsListInputSchema> {
     constructor(mcpServer: McpServer, logger: McpLogger);
-    handler({ path, account, absoluteCurrentWorkingDirectory, }: HsListInputSchema): Promise<TextContentResponse>;
+    handler({ path, account, absoluteCurrentWorkingDirectory }: HsListInputSchema, extra?: ToolExtra): Promise<TextContentResponse>;
     register(): RegisteredTool;
 }
 export {};

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

@@ -1,8 +1,7 @@
 import { Tool } from '../../Tool.js';
 import { z } from 'zod';
-import { addFlag } from '../../utils/command.js';
+import { HubSpotCommand } from '../../utils/command.js';
 import { absoluteCurrentWorkingDirectory } from '../project/constants.js';
-import { runCommandInDir } from '../../utils/command.js';
 import { formatTextContents } from '../../utils/content.js';
 import { setupHubSpotConfig } from '../../utils/config.js';
 import { getErrorMessage } from '../../../lib/errorHandlers/index.js';
@@ -24,17 +23,14 @@ export class HsListTool extends Tool {
     constructor(mcpServer, logger) {
         super(mcpServer, logger, toolName);
     }
-    async handler({ path, account, absoluteCurrentWorkingDirectory, }) {
+    async handler({ path, account, absoluteCurrentWorkingDirectory }, extra) {
         setupHubSpotConfig(absoluteCurrentWorkingDirectory);
-        let command = 'hs cms list';
-        if (path) {
-            command += ` ${path}`;
-        }
+        const command = new HubSpotCommand(path ? `cms list ${path}` : 'cms list');
         if (account) {
-            command = addFlag(command, 'account', account);
+            command.addFlag('account', account);
         }
         try {
-            const { stdout, stderr } = await runCommandInDir(absoluteCurrentWorkingDirectory, command);
+            const { stdout, stderr } = await this.runCommand(absoluteCurrentWorkingDirectory, command, extra);
             return formatTextContents(stdout, stderr);
         }
         catch (error) {
@@ -61,6 +57,6 @@ export class HsListTool extends Tool {
                 readOnlyHint: true,
                 openWorldHint: true,
             },
-        }, input => this.wrappedHandler(input));
+        }, (input, extra) => this.wrappedHandler(input, extra));
     }
 }

package/mcp-server/tools/index.js

@@ -19,6 +19,7 @@ import { HsListFunctionsTool } from './cms/HsListFunctionsTool.js';
 import { HsFunctionLogsTool } from './cms/HsFunctionLogsTool.js';
 import { CreateTestAccountTool } from './project/CreateTestAccountTool.js';
 import { FindProjectsTool } from './project/FindProjectsTool.js';
+import { AuthAccountTool } from './project/AuthAccountTool.js';
 export function registerProjectTools(mcpServer, logger) {
     return [
         new UploadProjectTools(mcpServer, logger).register(),
@@ -36,6 +37,7 @@ export function registerProjectTools(mcpServer, logger) {
         new GetBuildLogsTool(mcpServer, logger).register(),
         new GetBuildStatusTool(mcpServer, logger).register(),
         new FindProjectsTool(mcpServer, logger).register(),
+        new AuthAccountTool(mcpServer, logger).register(),
     ];
 }
 export function registerCmsTools(mcpServer, logger) {

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

@@ -1,5 +1,5 @@
 import { TextContentResponse } from '../../types.js';
-import { Tool } from '../../Tool.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';
@@ -32,7 +32,7 @@ declare const inputSchemaZodObject: z.ZodObject<{
 export type AddFeatureInputSchema = z.infer<typeof inputSchemaZodObject>;
 export declare class AddFeatureToProjectTool extends Tool<AddFeatureInputSchema> {
     constructor(mcpServer: McpServer, logger: McpLogger);
-    handler({ absoluteProjectPath, absoluteCurrentWorkingDirectory, distribution, auth, features, addApp, }: AddFeatureInputSchema): Promise<TextContentResponse>;
+    handler({ absoluteProjectPath, absoluteCurrentWorkingDirectory, distribution, auth, features, addApp, }: AddFeatureInputSchema, extra?: ToolExtra): Promise<TextContentResponse>;
     register(): RegisteredTool;
 }
 export {};

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

@@ -1,9 +1,8 @@
 import { Tool } from '../../Tool.js';
 import { z } from 'zod';
 import { APP_AUTH_TYPES, APP_DISTRIBUTION_TYPES, } from '../../../lib/constants.js';
-import { addFlag } from '../../utils/command.js';
+import { HubSpotCommand } from '../../utils/command.js';
 import { absoluteCurrentWorkingDirectory, absoluteProjectPath, features, } from './constants.js';
-import { runCommandInDir } from '../../utils/command.js';
 import { formatTextContents, formatTextContent } from '../../utils/content.js';
 import { setupHubSpotConfig } from '../../utils/config.js';
 import { getErrorMessage } from '../../../lib/errorHandlers/index.js';
@@ -32,19 +31,19 @@ export class AddFeatureToProjectTool extends Tool {
     constructor(mcpServer, logger) {
         super(mcpServer, logger, toolName);
     }
-    async handler({ absoluteProjectPath, absoluteCurrentWorkingDirectory, distribution, auth, features, addApp, }) {
+    async handler({ absoluteProjectPath, absoluteCurrentWorkingDirectory, distribution, auth, features, addApp, }, extra) {
         setupHubSpotConfig(absoluteCurrentWorkingDirectory);
         try {
-            let command = `hs project add`;
+            const command = new HubSpotCommand('project add');
             const content = [];
             if (distribution) {
-                command = addFlag(command, 'distribution', distribution);
+                command.addFlag('distribution', distribution);
             }
             else if (addApp) {
                 content.push(formatTextContent(`Ask the user how they would you like to distribute the app. Options are ${APP_DISTRIBUTION_TYPES.MARKETPLACE} and ${APP_DISTRIBUTION_TYPES.PRIVATE}`));
             }
             if (auth) {
-                command = addFlag(command, 'auth', auth);
+                command.addFlag('auth', auth);
             }
             else if (addApp) {
                 content.push(formatTextContent(`Ask the user which auth type they would like to use. Options are ${APP_AUTH_TYPES.STATIC} and ${APP_AUTH_TYPES.OAUTH}`));
@@ -55,8 +54,8 @@ export class AddFeatureToProjectTool extends Tool {
                 };
             }
             // If features isn't provided, pass an empty array to bypass the prompt
-            command = addFlag(command, 'features', features || []);
-            const { stdout, stderr } = await runCommandInDir(absoluteProjectPath, command);
+            command.addFlag('features', features || []);
+            const { stdout, stderr } = await this.runCommand(absoluteProjectPath, command, extra);
             return formatTextContents(stdout, stderr);
         }
         catch (error) {
@@ -79,6 +78,6 @@ export class AddFeatureToProjectTool extends Tool {
                 idempotentHint: false,
                 openWorldHint: false,
             },
-        }, input => this.wrappedHandler(input));
+        }, (input, extra) => this.wrappedHandler(input, extra));
     }
 }

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

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { McpServer, RegisteredTool } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { McpLogger } from '../../utils/logger.js';
+import { Tool, ToolExtra } from '../../Tool.js';
+import { TextContentResponse } from '../../types.js';
+declare const inputSchemaZodObject: z.ZodObject<{
+    absoluteCurrentWorkingDirectory: z.ZodString;
+    accountId: z.ZodOptional<z.ZodNumber>;
+    name: z.ZodOptional<z.ZodString>;
+    setAsDefault: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type AuthAccountInputSchema = z.infer<typeof inputSchemaZodObject>;
+export declare class AuthAccountTool extends Tool<AuthAccountInputSchema> {
+    constructor(mcpServer: McpServer, logger: McpLogger);
+    handler({ absoluteCurrentWorkingDirectory, accountId, name, setAsDefault, }: AuthAccountInputSchema, extra?: ToolExtra): Promise<TextContentResponse>;
+    register(): RegisteredTool;
+}
+export {};

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

@@ -0,0 +1,78 @@
+import { z } from 'zod';
+import { Tool } from '../../Tool.js';
+import { formatTextContents } from '../../utils/content.js';
+import { HubSpotCommand } from '../../utils/command.js';
+import { setupHubSpotConfig } from '../../utils/config.js';
+import { absoluteCurrentWorkingDirectory } from './constants.js';
+import { getErrorMessage } from '../../../lib/errorHandlers/index.js';
+const inputSchema = {
+    absoluteCurrentWorkingDirectory,
+    accountId: z
+        .number()
+        .optional()
+        .describe('The HubSpot portal ID to authenticate.'),
+    name: z
+        .string()
+        .optional()
+        .describe('A name to assign to this account in the HubSpot CLI config. Defaults to the portal name if not provided.'),
+    setAsDefault: z
+        .boolean()
+        .optional()
+        .describe('Set this account as the default for CLI operations. Defaults to true when not specified.'),
+};
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const inputSchemaZodObject = z.object({ ...inputSchema });
+const toolName = 'auth-account';
+export class AuthAccountTool extends Tool {
+    constructor(mcpServer, logger) {
+        super(mcpServer, logger, toolName);
+    }
+    async handler({ absoluteCurrentWorkingDirectory, accountId, name, setAsDefault, }, extra) {
+        setupHubSpotConfig(absoluteCurrentWorkingDirectory);
+        const command = new HubSpotCommand('account auth');
+        if (name) {
+            command.addFlag('name', name);
+        }
+        else {
+            command.addFlag('use-default-name', 'true');
+        }
+        if (accountId !== undefined) {
+            command.addFlag('account', accountId);
+        }
+        command.addFlag('default', setAsDefault === false ? 'false' : 'true');
+        try {
+            const { stdout, stderr } = await this.runCommand(absoluteCurrentWorkingDirectory, command, extra);
+            return formatTextContents(stdout, stderr);
+        }
+        catch (error) {
+            this.logger.debug(toolName, {
+                message: 'Handler caught error running hs account auth',
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return formatTextContents(getErrorMessage(error));
+        }
+    }
+    register() {
+        return this.mcpServer.registerTool(toolName, {
+            title: 'Authenticate a HubSpot Account',
+            description: 'Authenticates a HubSpot account with the CLI using `hs account auth`.\n\n' +
+                'WHEN TO USE:\n' +
+                '- The user wants to add or authenticate a HubSpot account\n' +
+                '- Any other tool reports that no account is configured\n' +
+                '- The user asks how to connect their HubSpot account to the CLI\n\n' +
+                'WORKFLOW:\n' +
+                '1. Call this tool — it opens a browser tab for the user to authorize\n' +
+                '2. The user clicks "Connect to CLI" in the browser\n' +
+                '3. Auth completes automatically via WebSocket\n' +
+                '4. Retry any operation that was blocked by missing auth\n\n' +
+                'setAsDefault defaults to true. Pass setAsDefault: false to keep an existing default account.',
+            inputSchema,
+            annotations: {
+                readOnlyHint: false,
+                destructiveHint: false,
+                idempotentHint: false,
+                openWorldHint: true,
+            },
+        }, (input, extra) => this.wrappedHandler(input, extra));
+    }
+}

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

@@ -1,5 +1,5 @@
 import { TextContentResponse } from '../../types.js';
-import { Tool } from '../../Tool.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';
@@ -36,7 +36,7 @@ declare const inputSchemaZodObject: z.ZodObject<{
 export type CreateProjectInputSchema = z.infer<typeof inputSchemaZodObject>;
 export declare class CreateProjectTool extends Tool<CreateProjectInputSchema> {
     constructor(mcpServer: McpServer, logger: McpLogger);
-    handler({ name, destination, projectBase, distribution, auth, features, absoluteCurrentWorkingDirectory, }: CreateProjectInputSchema): Promise<TextContentResponse>;
+    handler({ name, destination, projectBase, distribution, auth, features, absoluteCurrentWorkingDirectory, }: CreateProjectInputSchema, extra?: ToolExtra): Promise<TextContentResponse>;
     register(): RegisteredTool;
 }
 export {};

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

@@ -1,9 +1,8 @@
 import { Tool } from '../../Tool.js';
 import { z } from 'zod';
 import { APP_AUTH_TYPES, APP_DISTRIBUTION_TYPES, EMPTY_PROJECT, PROJECT_WITH_APP, } from '../../../lib/constants.js';
-import { addFlag } from '../../utils/command.js';
+import { HubSpotCommand } from '../../utils/command.js';
 import { absoluteCurrentWorkingDirectory, features } from './constants.js';
-import { runCommandInDir } from '../../utils/command.js';
 import { formatTextContents, formatTextContent } from '../../utils/content.js';
 import { setupHubSpotConfig } from '../../utils/config.js';
 import { getErrorMessage } from '../../../lib/errorHandlers/index.js';
@@ -37,30 +36,32 @@ export class CreateProjectTool extends Tool {
     constructor(mcpServer, logger) {
         super(mcpServer, logger, toolName);
     }
-    async handler({ name, destination, projectBase, distribution, auth, features, absoluteCurrentWorkingDirectory, }) {
+    async handler({ name, destination, projectBase, distribution, auth, features, absoluteCurrentWorkingDirectory, }, extra) {
         setupHubSpotConfig(absoluteCurrentWorkingDirectory);
-        let command = addFlag('hs project create', 'platform-version', PLATFORM_VERSIONS.v2026_03);
+        const command = new HubSpotCommand('project create', [
+            { name: 'platform-version', value: PLATFORM_VERSIONS.v2026_03 },
+        ]);
         const content = [];
         if (name) {
-            command = addFlag(command, 'name', name);
+            command.addFlag('name', name);
         }
         else {
             content.push(formatTextContent(`Ask the user what they would like to name the project.`));
         }
         if (destination) {
-            command = addFlag(command, 'dest', destination);
+            command.addFlag('dest', destination);
         }
         if (projectBase) {
-            command = addFlag(command, 'project-base', projectBase);
+            command.addFlag('project-base', projectBase);
         }
         if (distribution) {
-            command = addFlag(command, 'distribution', distribution);
+            command.addFlag('distribution', distribution);
         }
         else if (projectBase === PROJECT_WITH_APP) {
             content.push(formatTextContent(`Ask the user how they would you like to distribute the app? Options are ${APP_DISTRIBUTION_TYPES.MARKETPLACE} and ${APP_DISTRIBUTION_TYPES.PRIVATE}`));
         }
         if (auth) {
-            command = addFlag(command, 'auth', auth);
+            command.addFlag('auth', auth);
         }
         else if (projectBase === PROJECT_WITH_APP) {
             content.push(formatTextContent(`Ask the user which auth type they would like to use? Options are ${APP_AUTH_TYPES.STATIC} and ${APP_AUTH_TYPES.OAUTH}`));
@@ -71,9 +72,9 @@ export class CreateProjectTool extends Tool {
             };
         }
         // Always pass features, even if it is an empty array to bypass the prompts
-        command = addFlag(command, 'features', features || []);
+        command.addFlag('features', features || []);
         try {
-            const { stdout, stderr } = await runCommandInDir(absoluteCurrentWorkingDirectory, command);
+            const { stdout, stderr } = await this.runCommand(absoluteCurrentWorkingDirectory, command, extra);
             return formatTextContents(stdout, stderr);
         }
         catch (error) {
@@ -95,6 +96,6 @@ export class CreateProjectTool extends Tool {
                 idempotentHint: false,
                 openWorldHint: false,
             },
-        }, input => this.wrappedHandler(input));
+        }, (input, extra) => this.wrappedHandler(input, extra));
     }
 }

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

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