@hubspot/cli 7.7.19-experimental.0 → 7.7.19-experimental.2

package/lib/prompts/promptUtils.js

@@ -5,49 +5,175 @@ exports.promptUser = promptUser;
 exports.confirmPrompt = confirmPrompt;
 exports.listPrompt = listPrompt;
 exports.inputPrompt = inputPrompt;
-const inquirer = require('inquirer');
-const promptModule = inquirer.createPromptModule();
-exports.Separator = new inquirer.Separator();
+const prompts_1 = require("@inquirer/prompts");
+exports.Separator = new prompts_1.Separator();
+function mapPromptChoicesToChoices(choices) {
+    return (choices?.map(choice => {
+        if (typeof choice === 'string') {
+            return { value: choice, name: choice };
+        }
+        else if (choice instanceof prompts_1.Separator) {
+            return choice;
+        }
+        return {
+            value: choice.value,
+            name: choice.name,
+            disabled: choice.disabled,
+            checked: choice.checked,
+        };
+    }) || []);
+}
+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);
+            }
+            // 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;
+    })();
+}
 function promptUser(config) {
-    return promptModule(config);
+    if (Array.isArray(config)) {
+        return 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 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);
+    }
+}
+function handleRawListPrompt(config) {
+    const choices = mapPromptChoicesToChoices(config.choices);
+    choices.map((choice, index) => {
+        if (!(choice instanceof prompts_1.Separator)) {
+            choice.name = `${index + 1}) ${choice.name}`;
+        }
+    });
+    return (0, prompts_1.select)({
+        message: config.message,
+        choices: choices,
+        pageSize: config.pageSize,
+        default: config.default,
+    }).then(resp => ({ [config.name]: resp }));
+}
+function handleNumberPrompt(config) {
+    return (0, prompts_1.number)({
+        message: config.message,
+        default: config.default,
+        validate: config.validate,
+    }).then(resp => ({ [config.name]: resp }));
+}
+function handlePasswordPrompt(config) {
+    return (0, prompts_1.password)({
+        message: config.message,
+        mask: '*',
+        validate: config.validate,
+    }).then(resp => ({ [config.name]: resp }));
+}
+function handleCheckboxPrompt(config) {
+    const choices = mapPromptChoicesToChoices(config.choices);
+    return (0, prompts_1.checkbox)({
+        message: config.message,
+        choices: choices,
+        pageSize: config.pageSize,
+        validate: config.validate,
+    }).then(resp => ({ [config.name]: resp }));
+}
+function handleConfirmPrompt(config) {
+    return confirmPrompt(config.message, {
+        defaultAnswer: config.default,
+    }).then(resp => ({ [config.name]: resp }));
+}
+function handleInputPrompt(config) {
+    return (0, prompts_1.input)({
+        message: config.message,
+        default: config.default,
+        validate: config.validate,
+        transformer: config.transformer,
+    }).then(resp => ({ [config.name]: resp }));
+}
+function handleSelectPrompt(config) {
+    const choices = mapPromptChoicesToChoices(config.choices);
+    return (0, prompts_1.select)({
+        message: config.message,
+        choices: choices,
+        default: config.default,
+        pageSize: config.pageSize,
+    }).then(resp => ({ [config.name]: resp }));
 }
 async function confirmPrompt(message, options = {}) {
-    const { defaultAnswer = true, when } = options;
-    const { choice } = await promptUser([
-        {
-            name: 'choice',
-            type: 'confirm',
-            message,
-            default: defaultAnswer,
-            when,
-        },
-    ]);
+    const { defaultAnswer = true } = options;
+    const choice = await (0, prompts_1.confirm)({
+        message,
+        default: defaultAnswer,
+    });
     return choice;
 }
 async function listPrompt(message, { choices, when, defaultAnswer, validate, }) {
-    const { choice } = await promptUser([
-        {
-            name: 'choice',
-            type: 'list',
-            message,
-            choices,
-            when,
-            default: defaultAnswer,
-            validate,
-        },
-    ]);
+    const { choice } = await promptUser({
+        name: 'choice',
+        type: 'list',
+        message,
+        choices,
+        when,
+        default: defaultAnswer,
+        validate,
+    });
     return choice;
 }
 async function inputPrompt(message, { when, validate, defaultAnswer, } = {}) {
-    const { input } = await promptUser([
-        {
-            name: 'input',
-            type: 'input',
-            default: defaultAnswer,
-            message,
-            when,
-            validate,
-        },
-    ]);
+    const { input } = await promptUser({
+        name: 'input',
+        type: 'input',
+        default: defaultAnswer,
+        message,
+        when,
+        validate,
+    });
     return input;
 }

package/lib/prompts/selectProjectTemplatePrompt.d.ts

@@ -1,3 +1,4 @@
+import { Separator } from '@inquirer/prompts';
 import { ComponentTemplate, ComponentTemplateChoice, ProjectTemplate } from '../../types/Projects';
 export type SelectProjectTemplatePromptResponse = {
     projectTemplate?: ProjectTemplate;
@@ -22,5 +23,5 @@ export type PromptOptionsArg = {
     features?: string[];
 };
 export declare function selectProjectTemplatePrompt(promptOptions: PromptOptionsArg, projectTemplates?: ProjectTemplate[], componentTemplates?: undefined): Promise<SelectProjectTemplatePromptResponseProjectTemplate>;
-export declare function selectProjectTemplatePrompt(promptOptions: PromptOptionsArg, projectTemplates?: undefined, componentTemplates?: ComponentTemplateChoice[]): Promise<SelectProjectTemplatePromptResponseComponentTemplates>;
+export declare function selectProjectTemplatePrompt(promptOptions: PromptOptionsArg, projectTemplates?: undefined, componentTemplates?: (ComponentTemplateChoice | Separator)[]): Promise<SelectProjectTemplatePromptResponseComponentTemplates>;
 export {};

package/lib/prompts/selectProjectTemplatePrompt.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.selectProjectTemplatePrompt = selectProjectTemplatePrompt;
+const prompts_1 = require("@inquirer/prompts");
 const promptUtils_1 = require("./promptUtils");
 const en_1 = require("../../lang/en");
 function findTemplateByNameOrLabel(projectTemplates, templateNameOrLabel) {
@@ -12,7 +13,7 @@ async function selectProjectTemplatePrompt(promptOptions, projectTemplates, comp
     const selectedComponents = [];
     if (createProjectFromComponents && promptOptions.features) {
         componentTemplates.forEach(template => {
-            if (!template.value) {
+            if (template instanceof prompts_1.Separator || !template.value) {
                 return;
             }
             if (promptOptions.features?.includes(template.value.type)) {

package/lib/usageTracking.d.ts

@@ -13,9 +13,9 @@ type Meta = {
     file?: boolean;
     successful?: boolean;
 };
-export declare function trackCommandUsage(command: string, meta?: Meta, accountId?: number): void;
-export declare function trackHelpUsage(command: string): void;
-export declare function trackConvertFieldsUsage(command: string): void;
-export declare function trackAuthAction(command: string, authType: string, step: string, accountId?: number): void;
-export declare function trackCommandMetadataUsage(command: string, meta?: Meta, accountId?: number): void;
+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>;
+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 {};

package/lib/usageTracking.js

@@ -33,7 +33,7 @@ function getPlatform() {
             return process.platform;
     }
 }
-function trackCommandUsage(command, meta = {}, accountId) {
+async function trackCommandUsage(command, meta = {}, accountId) {
     if (!(0, config_1.isTrackingAllowed)()) {
         return;
     }
@@ -46,47 +46,88 @@ function trackCommandUsage(command, meta = {}, accountId) {
                 ? accountConfig.authType
                 : auth_1.API_KEY_AUTH_METHOD.value;
     }
-    trackCliInteraction({
-        action: 'cli-command',
-        command,
-        authType,
-        ...meta,
-        accountId,
+    setImmediate(async () => {
+        const usageTrackingEvent = {
+            action: 'cli-command',
+            os: getPlatform(),
+            ...getNodeVersionData(),
+            version: package_json_1.version,
+            command,
+            authType,
+            ...meta,
+        };
+        try {
+            await (0, trackUsage_1.trackUsage)('cli-interaction', EventClass.INTERACTION, usageTrackingEvent, accountId);
+            logger_1.logger.debug('Sent usage tracking command event: %o', usageTrackingEvent);
+        }
+        catch (e) {
+            (0, errorHandlers_1.debugError)(e);
+        }
     });
 }
-function trackHelpUsage(command) {
+async function trackHelpUsage(command) {
     if (!(0, config_1.isTrackingAllowed)()) {
         return;
     }
-    if (command) {
-        logger_1.logger.debug('Tracking help usage of "%s" sub-command', command);
+    try {
+        if (command) {
+            logger_1.logger.debug('Tracking help usage of "%s" sub-command', command);
+        }
+        else {
+            logger_1.logger.debug('Tracking help usage of main command');
+        }
+        await (0, trackUsage_1.trackUsage)('cli-interaction', EventClass.INTERACTION, {
+            action: 'cli-help',
+            os: getPlatform(),
+            ...getNodeVersionData(),
+            version: package_json_1.version,
+            command,
+        });
     }
-    else {
-        logger_1.logger.debug('Tracking help usage of main command');
+    catch (e) {
+        (0, errorHandlers_1.debugError)(e);
     }
-    trackCliInteraction({
-        action: 'cli-help',
-        command,
-    });
 }
-function trackConvertFieldsUsage(command) {
-    trackCliInteraction({
-        action: 'cli-process-fields',
-        command,
-    });
+async function trackConvertFieldsUsage(command) {
+    if (!(0, config_1.isTrackingAllowed)()) {
+        return;
+    }
+    try {
+        logger_1.logger.debug('Attempting to track usage of "%s" command', command);
+        await (0, trackUsage_1.trackUsage)('cli-interaction', EventClass.INTERACTION, {
+            action: 'cli-process-fields',
+            os: getPlatform(),
+            ...getNodeVersionData(),
+            version: package_json_1.version,
+            command,
+        });
+    }
+    catch (e) {
+        (0, errorHandlers_1.debugError)(e);
+    }
 }
-function trackAuthAction(command, authType, step, accountId) {
-    trackCliInteraction({
+async function trackAuthAction(command, authType, step, accountId) {
+    if (!(0, config_1.isTrackingAllowed)()) {
+        return;
+    }
+    const usageTrackingEvent = {
         action: 'cli-auth',
+        os: getPlatform(),
+        ...getNodeVersionData(),
+        version: package_json_1.version,
         command,
         authType,
-        accountId,
-        meta: {
-            step,
-        },
-    });
+        step,
+    };
+    try {
+        await (0, trackUsage_1.trackUsage)('cli-interaction', EventClass.INTERACTION, usageTrackingEvent, accountId);
+        logger_1.logger.debug('Sent usage tracking command event: %o', usageTrackingEvent);
+    }
+    catch (e) {
+        (0, errorHandlers_1.debugError)(e);
+    }
 }
-function trackCommandMetadataUsage(command, meta = {}, accountId) {
+async function trackCommandMetadataUsage(command, meta = {}, accountId) {
     if (!(0, config_1.isTrackingAllowed)()) {
         return;
     }
@@ -99,21 +140,9 @@ function trackCommandMetadataUsage(command, meta = {}, accountId) {
                 ? accountConfig.authType
                 : auth_1.API_KEY_AUTH_METHOD.value;
     }
-    trackCliInteraction({
-        action: 'cli-command-metadata',
-        command,
-        authType,
-        accountId,
-        meta,
-    });
-}
-function trackCliInteraction({ action, accountId, command, authType, meta = {}, }) {
-    try {
-        if (!(0, config_1.isTrackingAllowed)()) {
-            return;
-        }
+    setImmediate(async () => {
         const usageTrackingEvent = {
-            action,
+            action: 'cli-command-metadata',
             os: getPlatform(),
             ...getNodeVersionData(),
             version: package_json_1.version,
@@ -121,36 +150,12 @@ function trackCliInteraction({ action, accountId, command, authType, meta = {},
             authType,
             ...meta,
         };
-        if (process.env.HUBSPOT_MCP_AI_AGENT) {
-            setImmediate(async () => {
-                try {
-                    await (0, trackUsage_1.trackUsage)('cli-interaction', EventClass.INTERACTION, {
-                        ...usageTrackingEvent,
-                        action: 'cli-mcp-server',
-                        type: process.env.HUBSPOT_MCP_AI_AGENT,
-                    }, accountId);
-                    logger_1.logger.debug('Sent AI usage tracking command event: %o', {
-                        ...usageTrackingEvent,
-                        action: 'cli-mcp-server',
-                        type: process.env.HUBSPOT_MCP_AI_AGENT,
-                    });
-                }
-                catch (error) {
-                    (0, errorHandlers_1.debugError)(error);
-                }
-            });
+        try {
+            await (0, trackUsage_1.trackUsage)('cli-interaction', EventClass.INTERACTION, usageTrackingEvent, accountId);
+            logger_1.logger.debug('Sent usage tracking command event: %o', usageTrackingEvent);
         }
-        setImmediate(async () => {
-            try {
-                await (0, trackUsage_1.trackUsage)('cli-interaction', EventClass.INTERACTION, usageTrackingEvent, accountId);
-            }
-            catch (error) {
-                (0, errorHandlers_1.debugError)(error);
-            }
-        });
-        logger_1.logger.debug('Sent usage tracking command event: %o', usageTrackingEvent);
-    }
-    catch (e) {
-        (0, errorHandlers_1.debugError)(e);
-    }
+        catch (e) {
+            (0, errorHandlers_1.debugError)(e);
+        }
+    });
 }

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

@@ -14,17 +14,17 @@ declare const inputSchemaZodObject: z.ZodObject<{
     absoluteCurrentWorkingDirectory: string;
     destination: string;
     auth?: "oauth" | "static" | undefined;
+    name?: string | undefined;
     distribution?: "marketplace" | "private" | undefined;
     features?: ("card" | "settings" | "app-function" | "webhooks")[] | undefined;
-    name?: string | undefined;
 }, {
     projectBase: "app" | "empty";
     absoluteCurrentWorkingDirectory: string;
     destination: string;
     auth?: "oauth" | "static" | undefined;
+    name?: string | undefined;
     distribution?: "marketplace" | "private" | undefined;
     features?: ("card" | "settings" | "app-function" | "webhooks")[] | undefined;
-    name?: string | undefined;
 }>;
 export type CreateProjectInputSchema = z.infer<typeof inputSchemaZodObject>;
 export declare class CreateProjectTool extends Tool<CreateProjectInputSchema> {

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

@@ -21,7 +21,7 @@ class UploadProjectTools extends types_1.Tool {
         super(mcpServer);
     }
     async handler({ absoluteProjectPath, }) {
-        const { stdout, stderr } = await (0, project_1.runCommandInDir)(absoluteProjectPath, `hs project upload --force-create --debug`);
+        const { stdout, stderr } = await (0, project_1.runCommandInDir)(absoluteProjectPath, `hs project upload --force-create`);
         return (0, content_1.formatTextContents)(stdout, stderr);
     }
     register() {

package/mcp-server/utils/project.js

@@ -13,8 +13,5 @@ async function runCommandInDir(directory, command) {
     }
     return (0, command_1.execAsync)(command, {
         cwd: path_1.default.resolve(directory),
-        env: {
-            ...process.env,
-        },
     });
 }

package/package.json

@@ -1,11 +1,11 @@
 {
     "name": "@hubspot/cli",
-    "version": "7.7.19-experimental.0",
+    "version": "7.7.19-experimental.2",
     "description": "The official CLI for developing on HubSpot",
     "license": "Apache-2.0",
     "repository": "https://github.com/HubSpot/hubspot-cli",
     "dependencies": {
-        "@hubspot/local-dev-lib": "3.12.0",
+        "@hubspot/local-dev-lib": "3.13.1",
         "@hubspot/project-parsing-lib": "0.5.1",
         "@hubspot/serverless-dev-runtime": "7.0.6",
         "@hubspot/theme-preview-dev-server": "0.0.10",
@@ -19,7 +19,7 @@
         "express": "4.21.2",
         "findup-sync": "4.0.0",
         "fs-extra": "8.1.0",
-        "inquirer": "8.2.0",
+        "inquirer": "12.7.0",
         "js-yaml": "4.1.0",
         "moment": "2.30.1",
         "open": "7.4.2",

package/types/Prompts.d.ts

@@ -1,3 +1,4 @@
+import { Separator } from '@inquirer/prompts';
 export type GenericPromptResponse = {
     [key: string]: any;
 };
@@ -6,9 +7,10 @@ export type PromptChoices<T = any> = Array<string | {
     name: string;
     value?: T;
     disabled?: string | boolean;
-}>;
+    checked?: boolean;
+} | Separator>;
 export type PromptWhen = boolean | (() => boolean);
-type PromptOperand = string | number | boolean | string[] | boolean[] | null;
+export type PromptOperand = string | number | boolean | string[] | boolean[] | null;
 export type PromptConfig<T extends GenericPromptResponse> = {
     name: keyof T;
     type?: PromptType;