@hubspot/cli 7.7.21-experimental.0 → 7.7.22-experimental.0

package/lib/prompts/createDeveloperTestAccountConfigPrompt.d.ts

@@ -1,17 +1,18 @@
-import { DeveloperTestAccountConfig } from '@hubspot/local-dev-lib/types/developerTestAccounts.js';
+import { AccountLevel, DeveloperTestAccountConfig } from '@hubspot/local-dev-lib/types/developerTestAccounts.js';
 declare const hubs: {
-    readonly MARKETING: "marketingLevel";
-    readonly OPS: "opsLevel";
-    readonly SERVICE: "serviceLevel";
-    readonly SALES: "salesLevel";
-    readonly CONTENT: "contentLevel";
+    MARKETING: string;
+    OPS: string;
+    SERVICE: string;
+    SALES: string;
+    CONTENT: string;
 };
 type HubName = keyof typeof hubs;
-type HubTier = 'STARTER' | 'PROFESSIONAL' | 'ENTERPRISE';
-export type HubConfig = `${HubName}:${HubTier}`;
+export type HubConfig = {
+    hub: HubName;
+    tier: AccountLevel;
+};
 export declare function createDeveloperTestAccountConfigPrompt(args?: {
     name?: string;
     description?: string;
-    tiers?: HubConfig[];
-}): Promise<DeveloperTestAccountConfig>;
+}, supportFlags?: boolean): Promise<DeveloperTestAccountConfig>;
 export {};

package/lib/prompts/createDeveloperTestAccountConfigPrompt.js

@@ -1,6 +1,6 @@
+import { Separator } from '@inquirer/prompts';
 import { lib } from '../../lang/en.js';
 import { promptUser } from './promptUtils.js';
-import { Separator } from '@inquirer/prompts';
 const hubs = {
     MARKETING: 'marketingLevel',
     OPS: 'opsLevel',
@@ -8,63 +8,108 @@ const hubs = {
     SALES: 'salesLevel',
     CONTENT: 'contentLevel',
 };
+const AccountTiers = {
+    FREE: 'FREE',
+    STARTER: 'STARTER',
+    PROFESSIONAL: 'PROFESSIONAL',
+    ENTERPRISE: 'ENTERPRISE',
+};
+const makeHubTiers = (hubKey) => {
+    const hubTypeKey = hubKey.toLowerCase();
+    const hubName = lib.prompts.createDeveloperTestAccountConfigPrompt.hubTypes[hubTypeKey];
+    return [
+        {
+            name: `${hubName} [${AccountTiers.FREE}]`,
+            value: { hub: hubKey, tier: AccountTiers.FREE },
+        },
+        {
+            name: `${hubName} [${AccountTiers.STARTER}]`,
+            value: { hub: hubKey, tier: AccountTiers.STARTER },
+        },
+        {
+            name: `${hubName} [${AccountTiers.PROFESSIONAL}]`,
+            value: { hub: hubKey, tier: AccountTiers.PROFESSIONAL },
+        },
+        {
+            name: `${hubName} [${AccountTiers.ENTERPRISE}]`,
+            value: { hub: hubKey, tier: AccountTiers.ENTERPRISE },
+        },
+    ];
+};
 const TEST_ACCOUNT_TIERS = [
-    { name: 'Marketing STARTER', value: 'MARKETING:STARTER' },
-    {
-        name: 'Marketing PROFESSIONAL',
-        value: 'MARKETING:PROFESSIONAL',
-    },
-    { name: 'Marketing ENTERPRISE', value: 'MARKETING:ENTERPRISE' },
+    ...makeHubTiers('MARKETING'),
     new Separator(),
-    { name: 'Ops STARTER', value: 'OPS:STARTER' },
-    { name: 'Ops PROFESSIONAL', value: 'OPS:PROFESSIONAL' },
-    { name: 'Ops ENTERPRISE', value: 'OPS:ENTERPRISE' },
+    ...makeHubTiers('OPS'),
     new Separator(),
-    { name: 'Service STARTER', value: 'SERVICE:STARTER' },
-    { name: 'Service PROFESSIONAL', value: 'SERVICE:PROFESSIONAL' },
-    { name: 'Service ENTERPRISE', value: 'SERVICE:ENTERPRISE' },
+    ...makeHubTiers('SERVICE'),
     new Separator(),
-    { name: 'Sales STARTER', value: 'SALES:STARTER' },
-    { name: 'Sales PROFESSIONAL', value: 'SALES:PROFESSIONAL' },
-    { name: 'Sales ENTERPRISE', value: 'SALES:ENTERPRISE' },
+    ...makeHubTiers('SALES'),
     new Separator(),
-    { name: 'Content STARTER', value: 'CONTENT:STARTER' },
-    { name: 'Content PROFESSIONAL', value: 'CONTENT:PROFESSIONAL' },
-    { name: 'Content ENTERPRISE', value: 'CONTENT:ENTERPRISE' },
+    ...makeHubTiers('CONTENT'),
     new Separator(),
 ];
-export async function createDeveloperTestAccountConfigPrompt(args = {}) {
-    const { name, description, tiers } = args;
+export async function createDeveloperTestAccountConfigPrompt(args = {}, supportFlags = true) {
+    const { name, description } = args;
     let accountName = name;
     let accountDescription = description;
-    let accountLevelsArray = tiers;
+    let accountLevelsArray = [];
     if (!accountName) {
         const namePromptResult = await promptUser({
             name: 'accountName',
-            message: lib.prompts.createDeveloperTestAccountConfigPrompt.namePrompt,
+            message: lib.prompts.createDeveloperTestAccountConfigPrompt.namePrompt(supportFlags),
             type: 'input',
+            validate: value => {
+                if (!value) {
+                    return lib.prompts.createDeveloperTestAccountConfigPrompt.errors
+                        .nameRequired;
+                }
+                return true;
+            },
         });
         accountName = namePromptResult.accountName;
     }
     if (!accountDescription) {
         const descriptionPromptResult = await promptUser({
             name: 'description',
-            message: lib.prompts.createDeveloperTestAccountConfigPrompt.descriptionPrompt,
+            message: lib.prompts.createDeveloperTestAccountConfigPrompt.descriptionPrompt(supportFlags),
             type: 'input',
         });
         accountDescription = descriptionPromptResult.description;
     }
-    if (!accountLevelsArray) {
+    const useDefaultAccountLevelsPromptResult = await promptUser({
+        name: 'useDefaultAccountLevels',
+        message: lib.prompts.createDeveloperTestAccountConfigPrompt
+            .useDefaultAccountLevelsPrompt.message,
+        type: 'list',
+        choices: [
+            {
+                name: lib.prompts.createDeveloperTestAccountConfigPrompt
+                    .useDefaultAccountLevelsPrompt.default,
+                value: 'default',
+            },
+            {
+                name: lib.prompts.createDeveloperTestAccountConfigPrompt
+                    .useDefaultAccountLevelsPrompt.manual,
+                value: 'manual',
+            },
+        ],
+    });
+    if (useDefaultAccountLevelsPromptResult.useDefaultAccountLevels === 'manual') {
         const accountLevelsPromptResult = await promptUser({
             name: 'testAccountLevels',
             message: lib.prompts.createDeveloperTestAccountConfigPrompt.tiersPrompt,
             type: 'checkbox',
+            pageSize: 13,
             choices: TEST_ACCOUNT_TIERS,
             validate: choices => {
-                if (choices?.length > 1) {
+                if (choices?.length < Object.keys(hubs).length) {
+                    return lib.prompts.createDeveloperTestAccountConfigPrompt.errors
+                        .allHubsRequired;
+                }
+                else {
                     const hubMap = {};
                     for (const choice of choices) {
-                        const hub = choice.split(':')[0];
+                        const { hub } = choice.value;
                         if (hubMap[hub]) {
                             return lib.prompts.createDeveloperTestAccountConfigPrompt.errors
                                 .tiersError;
@@ -77,11 +122,8 @@ export async function createDeveloperTestAccountConfigPrompt(args = {}) {
         });
         accountLevelsArray = accountLevelsPromptResult.testAccountLevels;
     }
-    if (!accountLevelsArray) {
-        accountLevelsArray = [];
-    }
     const accountLevels = accountLevelsArray.reduce((acc, level) => {
-        const [hubName, hubTier] = level.split(':');
+        const { hub: hubName, tier: hubTier } = level;
         const hubLevel = hubs[hubName];
         acc[hubLevel] = hubTier;
         return acc;

package/lib/prompts/promptUtils.js

@@ -1,5 +1,9 @@
 import { confirm, Separator as _Separator, select, input, checkbox, password, number, } from '@inquirer/prompts';
+import { EXIT_CODES } from '../enums/exitCodes.js';
 export const Separator = new _Separator();
+function isUserCancellationError(error) {
+    return error instanceof Error && error.name === 'ExitPromptError';
+}
 function mapPromptChoicesToChoices(choices) {
     return (choices?.map(choice => {
         if (typeof choice === 'string') {
@@ -16,68 +20,74 @@ function mapPromptChoicesToChoices(choices) {
         };
     }) || []);
 }
-function handleArrayConfig(config) {
-    return (async () => {
-        const result = {};
-        for (const prompt of config) {
-            if (prompt.when !== undefined) {
-                const shouldPrompt = typeof prompt.when === 'function'
-                    ? prompt.when()
-                    : (prompt.when ?? true);
-                if (!shouldPrompt) {
-                    continue;
-                }
-            }
-            if (typeof prompt.message === 'function') {
-                prompt.message = prompt.message(result);
+async function handleArrayConfig(config) {
+    const result = {};
+    for (const prompt of config) {
+        if (prompt.when !== undefined) {
+            const shouldPrompt = typeof prompt.when === 'function'
+                ? prompt.when()
+                : (prompt.when ?? true);
+            if (!shouldPrompt) {
+                continue;
             }
-            // Pass the accumulated results to each prompt
-            const promptWithAnswers = {
-                ...prompt,
-                default: typeof prompt.default === 'function'
-                    ? (answers) => {
-                        const mergedAnswers = { ...answers, ...result };
-                        return prompt.default(mergedAnswers);
-                    }
-                    : prompt.default,
-            };
-            const response = await promptUser(promptWithAnswers);
-            Object.assign(result, response);
         }
-        return result;
-    })();
-}
-export function promptUser(config) {
-    if (Array.isArray(config)) {
-        return handleArrayConfig(config);
+        if (typeof prompt.message === 'function') {
+            prompt.message = prompt.message(result);
+        }
+        // Pass the accumulated results to each prompt
+        const promptWithAnswers = {
+            ...prompt,
+            default: typeof prompt.default === 'function'
+                ? (answers) => {
+                    const mergedAnswers = { ...answers, ...result };
+                    return prompt.default(mergedAnswers);
+                }
+                : prompt.default,
+        };
+        const response = await promptUser(promptWithAnswers);
+        Object.assign(result, response);
     }
-    else {
-        if (config.when !== undefined) {
-            const shouldPrompt = typeof config.when === 'function'
-                ? config.when()
-                : (config.when ?? true);
-            if (!shouldPrompt) {
-                return Promise.resolve({});
+    return result;
+}
+export async function promptUser(config) {
+    try {
+        if (Array.isArray(config)) {
+            return await handleArrayConfig(config);
+        }
+        else {
+            if (config.when !== undefined) {
+                const shouldPrompt = typeof config.when === 'function'
+                    ? config.when()
+                    : (config.when ?? true);
+                if (!shouldPrompt) {
+                    return Promise.resolve({});
+                }
             }
         }
+        switch (config.type) {
+            case 'list':
+                return await handleSelectPrompt(config);
+            case 'input':
+                return await handleInputPrompt(config);
+            case 'confirm':
+                return await handleConfirmPrompt(config);
+            case 'checkbox':
+                return await handleCheckboxPrompt(config);
+            case 'password':
+                return await handlePasswordPrompt(config);
+            case 'number':
+                return await handleNumberPrompt(config);
+            case 'rawlist':
+                return await handleRawListPrompt(config);
+            default:
+                return await handleInputPrompt(config);
+        }
     }
-    switch (config.type) {
-        case 'list':
-            return handleSelectPrompt(config);
-        case 'input':
-            return handleInputPrompt(config);
-        case 'confirm':
-            return handleConfirmPrompt(config);
-        case 'checkbox':
-            return handleCheckboxPrompt(config);
-        case 'password':
-            return handlePasswordPrompt(config);
-        case 'number':
-            return handleNumberPrompt(config);
-        case 'rawlist':
-            return handleRawListPrompt(config);
-        default:
-            return handleInputPrompt(config);
+    catch (error) {
+        if (isUserCancellationError(error)) {
+            process.exit(EXIT_CODES.SUCCESS);
+        }
+        throw error;
     }
 }
 function handleRawListPrompt(config) {

package/lib/prompts/sandboxesPrompt.d.ts

@@ -1,4 +1,4 @@
-import { SandboxAccountType } from '../../types/sandboxes.js';
+import { SandboxAccountType } from '../../types/Sandboxes.js';
 type SandboxTypePromptResponse = {
     type: SandboxAccountType;
 };

package/lib/sandboxSync.d.ts

@@ -1,4 +1,4 @@
 import { CLIAccount } from '@hubspot/local-dev-lib/types/Accounts';
 import { Environment } from '@hubspot/local-dev-lib/types/Config';
-import { SandboxSyncTask } from '../types/sandboxes.js';
+import { SandboxSyncTask } from '../types/Sandboxes.js';
 export declare function syncSandbox(accountConfig: CLIAccount, parentAccountConfig: CLIAccount, env: Environment, syncTasks: Array<SandboxSyncTask>, slimInfoMessage?: boolean): Promise<void>;

package/lib/sandboxes.d.ts

@@ -1,6 +1,6 @@
 import { AccountType, CLIAccount } from '@hubspot/local-dev-lib/types/Accounts';
 import { Environment } from '@hubspot/local-dev-lib/types/Config';
-import { SandboxSyncTask, SandboxAccountType } from '../types/sandboxes.js';
+import { SandboxSyncTask, SandboxAccountType } from '../types/Sandboxes.js';
 export declare const SYNC_TYPES: {
     readonly OBJECT_RECORDS: "object-records";
 };

package/lib/schema.js

@@ -6,6 +6,10 @@ export function logSchemas(schemas) {
     const data = schemas
         .map(r => [r.labels.singular, r.name, r.objectTypeId || ''])
         .sort((a, b) => (a[1] > b[1] ? 1 : -1));
+    if (data.length === 0) {
+        logger.log('No Schemas were found');
+        return;
+    }
     data.unshift([
         chalk.bold('Label'),
         chalk.bold('Name'),
@@ -15,7 +19,7 @@ export function logSchemas(schemas) {
         singleLine: true,
         border: getBorderCharacters('honeywell'),
     };
-    logger.log(data.length ? table(data, tableConfig) : 'No Schemas were found');
+    logger.log(table(data, tableConfig));
 }
 export async function listSchemas(accountId) {
     const { data } = await fetchObjectSchemas(accountId);

package/lib/ui/index.js

@@ -41,7 +41,7 @@ export function uiAccountDescription(accountId, bold = true) {
     const account = getAccountConfig(accountId || undefined);
     let message;
     if (account && account.accountType) {
-        message = `${account.name} [${HUBSPOT_ACCOUNT_TYPE_STRINGS[account.accountType]}] (${accountId})`;
+        message = `${account.name ? `${account.name} ` : ''}[${HUBSPOT_ACCOUNT_TYPE_STRINGS[account.accountType]}] (${accountId})`;
     }
     else {
         message = accountId ? accountId.toString() : '';

package/lib/usageTracking.d.ts

@@ -13,6 +13,17 @@ type Meta = {
     file?: boolean;
     successful?: boolean;
 };
+export declare const EventClass: {
+    USAGE: string;
+    INTERACTION: string;
+    VIEW: string;
+    ACTIVATION: string;
+};
+export declare function getNodeVersionData(): {
+    nodeVersion: string;
+    nodeMajorVersion: string;
+};
+export declare function getPlatform(): string;
 export declare function trackCommandUsage(command: string, meta?: Meta, accountId?: number): Promise<void>;
 export declare function trackHelpUsage(command: string): Promise<void>;
 export declare function trackConvertFieldsUsage(command: string): Promise<void>;

package/lib/usageTracking.js

@@ -5,19 +5,19 @@ import { logger } from '@hubspot/local-dev-lib/logger';
 import packageJson from '../package.json' with { type: 'json' };
 const version = packageJson.version;
 import { debugError } from './errorHandlers/index.js';
-const EventClass = {
+export const EventClass = {
     USAGE: 'USAGE',
     INTERACTION: 'INTERACTION',
     VIEW: 'VIEW',
     ACTIVATION: 'ACTIVATION',
 };
-function getNodeVersionData() {
+export function getNodeVersionData() {
     return {
         nodeVersion: process.version,
         nodeMajorVersion: (process.version || '').split('.')[0],
     };
 }
-function getPlatform() {
+export function getPlatform() {
     switch (process.platform) {
         case 'darwin':
             return 'macos';
@@ -40,86 +40,45 @@ export async function trackCommandUsage(command, meta = {}, accountId) {
                 ? accountConfig.authType
                 : API_KEY_AUTH_METHOD.value;
     }
-    setImmediate(async () => {
-        const usageTrackingEvent = {
-            action: 'cli-command',
-            os: getPlatform(),
-            ...getNodeVersionData(),
-            version,
-            command,
-            authType,
-            ...meta,
-        };
-        try {
-            await trackUsage('cli-interaction', EventClass.INTERACTION, usageTrackingEvent, accountId);
-            logger.debug('Sent usage tracking command event: %o', usageTrackingEvent);
-        }
-        catch (e) {
-            debugError(e);
-        }
+    return trackCliInteraction({
+        action: 'cli-command',
+        command,
+        authType,
+        ...meta,
+        accountId,
     });
 }
 export async function trackHelpUsage(command) {
     if (!isTrackingAllowed()) {
         return;
     }
-    try {
-        if (command) {
-            logger.debug('Tracking help usage of "%s" sub-command', command);
-        }
-        else {
-            logger.debug('Tracking help usage of main command');
-        }
-        await trackUsage('cli-interaction', EventClass.INTERACTION, {
-            action: 'cli-help',
-            os: getPlatform(),
-            ...getNodeVersionData(),
-            version,
-            command,
-        });
+    if (command) {
+        logger.debug('Tracking help usage of "%s" sub-command', command);
     }
-    catch (e) {
-        debugError(e);
+    else {
+        logger.debug('Tracking help usage of main command');
     }
+    return trackCliInteraction({
+        action: 'cli-help',
+        command,
+    });
 }
 export async function trackConvertFieldsUsage(command) {
-    if (!isTrackingAllowed()) {
-        return;
-    }
-    try {
-        logger.debug('Attempting to track usage of "%s" command', command);
-        await trackUsage('cli-interaction', EventClass.INTERACTION, {
-            action: 'cli-process-fields',
-            os: getPlatform(),
-            ...getNodeVersionData(),
-            version,
-            command,
-        });
-    }
-    catch (e) {
-        debugError(e);
-    }
+    return trackCliInteraction({
+        action: 'cli-process-fields',
+        command,
+    });
 }
 export async function trackAuthAction(command, authType, step, accountId) {
-    if (!isTrackingAllowed()) {
-        return;
-    }
-    const usageTrackingEvent = {
+    return trackCliInteraction({
         action: 'cli-auth',
-        os: getPlatform(),
-        ...getNodeVersionData(),
-        version,
         command,
         authType,
-        step,
-    };
-    try {
-        await trackUsage('cli-interaction', EventClass.INTERACTION, usageTrackingEvent, accountId);
-        logger.debug('Sent usage tracking command event: %o', usageTrackingEvent);
-    }
-    catch (e) {
-        debugError(e);
-    }
+        accountId,
+        meta: {
+            step,
+        },
+    });
 }
 export async function trackCommandMetadataUsage(command, meta = {}, accountId) {
     if (!isTrackingAllowed()) {
@@ -134,9 +93,21 @@ export async function trackCommandMetadataUsage(command, meta = {}, accountId) {
                 ? accountConfig.authType
                 : API_KEY_AUTH_METHOD.value;
     }
-    setImmediate(async () => {
+    return trackCliInteraction({
+        action: 'cli-command-metadata',
+        command,
+        authType,
+        accountId,
+        meta,
+    });
+}
+async function trackCliInteraction({ action, accountId, command, authType, meta = {}, }) {
+    try {
+        if (!isTrackingAllowed()) {
+            return;
+        }
         const usageTrackingEvent = {
-            action: 'cli-command-metadata',
+            action,
             os: getPlatform(),
             ...getNodeVersionData(),
             version,
@@ -144,12 +115,32 @@ export async function trackCommandMetadataUsage(command, meta = {}, accountId) {
             authType,
             ...meta,
         };
+        if (process.env.HUBSPOT_MCP_AI_AGENT) {
+            try {
+                await trackUsage('cli-interaction', EventClass.INTERACTION, {
+                    ...usageTrackingEvent,
+                    action: 'cli-mcp-server',
+                    type: process.env.HUBSPOT_MCP_AI_AGENT,
+                }, accountId);
+                logger.debug('Sent AI usage tracking command event: %o', {
+                    ...usageTrackingEvent,
+                    action: 'cli-mcp-server',
+                    type: process.env.HUBSPOT_MCP_AI_AGENT,
+                });
+            }
+            catch (error) {
+                debugError(error);
+            }
+        }
         try {
-            await trackUsage('cli-interaction', EventClass.INTERACTION, usageTrackingEvent, accountId);
-            logger.debug('Sent usage tracking command event: %o', usageTrackingEvent);
+            return trackUsage('cli-interaction', EventClass.INTERACTION, usageTrackingEvent, accountId);
         }
-        catch (e) {
-            debugError(e);
+        catch (error) {
+            debugError(error);
         }
-    });
+        logger.debug('Sent usage tracking command event: %o', usageTrackingEvent);
+    }
+    catch (e) {
+        debugError(e);
+    }
 }

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

@@ -5,6 +5,7 @@ import { addFlag } from '../../utils/command.js';
 import { absoluteProjectPath } from './constants.js';
 import { runCommandInDir } from '../../utils/project.js';
 import { formatTextContents, formatTextContent } from '../../utils/content.js';
+import { trackToolUsage } from '../../utils/toolUsageTracking.js';
 const inputSchema = {
     absoluteProjectPath,
     addApp: z
@@ -37,12 +38,14 @@ const inputSchema = {
 const inputSchemaZodObject = z.object({
     ...inputSchema,
 });
+const toolName = 'add-feature-to-hubspot-project';
 export class AddFeatureToProject extends Tool {
     constructor(mcpServer) {
         super(mcpServer);
     }
     async handler({ absoluteProjectPath, distribution, auth, features, addApp, }) {
         try {
+            await trackToolUsage(toolName);
             let command = `hs project add`;
             const content = [];
             if (distribution) {
@@ -72,7 +75,7 @@ export class AddFeatureToProject extends Tool {
         }
     }
     register() {
-        return this.mcpServer.registerTool('add-feature-to-hubspot-project', {
+        return this.mcpServer.registerTool(toolName, {
             title: 'Add feature to HubSpot Project',
             description: 'Adds a feature to an existing HubSpot project',
             inputSchema,

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

@@ -13,16 +13,16 @@ declare const inputSchemaZodObject: z.ZodObject<{
     projectBase: "app" | "empty";
     absoluteCurrentWorkingDirectory: string;
     destination: string;
-    auth?: "oauth" | "static" | undefined;
     name?: string | undefined;
+    auth?: "oauth" | "static" | undefined;
     distribution?: "marketplace" | "private" | undefined;
     features?: ("card" | "settings" | "app-function" | "webhooks")[] | undefined;
 }, {
     projectBase: "app" | "empty";
     absoluteCurrentWorkingDirectory: string;
     destination: string;
-    auth?: "oauth" | "static" | undefined;
     name?: string | undefined;
+    auth?: "oauth" | "static" | undefined;
     distribution?: "marketplace" | "private" | undefined;
     features?: ("card" | "settings" | "app-function" | "webhooks")[] | undefined;
 }>;