@hubspot/cli 7.7.0-experimental.3 → 7.7.0

package/lib/links.js

@@ -1,18 +1,10 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSiteLinksAsArray = getSiteLinksAsArray;
-exports.logSiteLinks = logSiteLinks;
-exports.openLink = openLink;
-const open_1 = __importDefault(require("open"));
-const config_1 = require("@hubspot/local-dev-lib/config");
-const environments_1 = require("@hubspot/local-dev-lib/constants/environments");
-const urls_1 = require("@hubspot/local-dev-lib/urls");
-const logger_1 = require("@hubspot/local-dev-lib/logger");
-const table_1 = require("./ui/table");
-const SITE_LINKS = {
+import open from 'open';
+import { getEnv } from '@hubspot/local-dev-lib/config';
+import { ENVIRONMENTS } from '@hubspot/local-dev-lib/constants/environments';
+import { getHubSpotWebsiteOrigin } from '@hubspot/local-dev-lib/urls';
+import { logger } from '@hubspot/local-dev-lib/logger';
+import { getTableContents, getTableHeader } from './ui/table.js';
+const COMMON_SITE_LINKS = {
     APPS_MARKETPLACE: {
         shortcut: 'apps-marketplace',
         alias: 'apm',
@@ -82,28 +74,35 @@ const SITE_LINKS = {
         getUrl: (accountId, baseUrl) => `${baseUrl}/website/${accountId}/pages/site`,
     },
 };
-function getSiteLinksAsArray(accountId) {
-    const baseUrl = (0, urls_1.getHubSpotWebsiteOrigin)((0, config_1.getEnv)() === 'qa' ? environments_1.ENVIRONMENTS.QA : environments_1.ENVIRONMENTS.PROD);
-    return Object.values(SITE_LINKS)
+export function getSiteLinksAsArray(accountId) {
+    const baseUrl = getHubSpotWebsiteOrigin(getEnv() === 'qa' ? ENVIRONMENTS.QA : ENVIRONMENTS.PROD);
+    return Object.values(COMMON_SITE_LINKS)
         .sort((a, b) => (a.shortcut < b.shortcut ? -1 : 1))
         .map(l => ({ ...l, url: l.getUrl(accountId, baseUrl) }));
 }
-function logSiteLinks(accountId) {
+export function logSiteLinks(accountId) {
     const linksAsArray = getSiteLinksAsArray(accountId).map(l => [
         `${l.shortcut}${l.alias ? ` [alias: ${l.alias}]` : ''}`,
         '=>',
         l.url,
     ]);
-    linksAsArray.unshift((0, table_1.getTableHeader)(['Shortcut', '', 'Url']));
-    logger_1.logger.log((0, table_1.getTableContents)(linksAsArray));
+    linksAsArray.unshift(getTableHeader(['Shortcut', '', 'Url']));
+    logger.log(getTableContents(linksAsArray));
 }
-function openLink(accountId, shortcut) {
-    const match = Object.values(SITE_LINKS).find(l => l.shortcut === shortcut || (l.alias && l.alias === shortcut));
+export function openLink(accountId, shortcut) {
+    const match = Object.values(COMMON_SITE_LINKS).find(l => l.shortcut === shortcut || (l.alias && l.alias === shortcut));
     if (!match) {
-        logger_1.logger.error(`We couldn't find a shortcut matching ${shortcut}.  Type 'hs open list' to see a list of available shortcuts`);
+        logger.error(`We couldn't find a shortcut matching ${shortcut}.  Type 'hs open list' to see a list of available shortcuts`);
         return;
     }
-    const baseUrl = (0, urls_1.getHubSpotWebsiteOrigin)((0, config_1.getEnv)() === 'qa' ? environments_1.ENVIRONMENTS.QA : environments_1.ENVIRONMENTS.PROD);
-    (0, open_1.default)(match.getUrl(accountId, baseUrl), { url: true });
-    logger_1.logger.success(`We opened ${match.getUrl(accountId, baseUrl)} in your browser`);
+    const baseUrl = getHubSpotWebsiteOrigin(getEnv() === 'qa' ? ENVIRONMENTS.QA : ENVIRONMENTS.PROD);
+    open(match.getUrl(accountId, baseUrl), { url: true });
+    logger.success(`We opened ${match.getUrl(accountId, baseUrl)} in your browser`);
+}
+export function getProductUpdatesUrl(rolloutId, accountId) {
+    const baseUrl = getHubSpotWebsiteOrigin(getEnv() === 'qa' ? ENVIRONMENTS.QA : ENVIRONMENTS.PROD);
+    if (accountId) {
+        return `${baseUrl}/product-updates/${accountId}/in-beta?rollout=${rolloutId}`;
+    }
+    return `${baseUrl}/l/product-updates/in-beta?rollout=${rolloutId}`;
 }

package/lib/marketplaceValidate.d.ts

@@ -2,5 +2,15 @@ import { GetValidationResultsResponse } from '@hubspot/local-dev-lib/types/Marke
 export declare function kickOffValidation(accountId: number, assetType: string, src: string): Promise<number>;
 export declare function pollForValidationFinish(accountId: number, validationId: number): Promise<void>;
 export declare function fetchValidationResults(accountId: number, validationId: number): Promise<GetValidationResultsResponse>;
-export declare function processValidationErrors(i18nKey: string, validationResults: GetValidationResultsResponse): void;
-export declare function displayValidationResults(i18nKey: string, validationResults: GetValidationResultsResponse): void;
+export declare function processValidationErrors(invalidPathError: (path: string) => string, validationResults: GetValidationResultsResponse): void;
+type ResultsCopy = {
+    noErrors: string;
+    required: string;
+    recommended: string;
+    warnings: {
+        file: (file: string) => string;
+        lineNumber: (line: string) => string;
+    };
+};
+export declare function displayValidationResults(resultsCopy: ResultsCopy, validationResults: GetValidationResultsResponse): void;
+export {};

package/lib/marketplaceValidate.js

@@ -1,23 +1,12 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.kickOffValidation = kickOffValidation;
-exports.pollForValidationFinish = pollForValidationFinish;
-exports.fetchValidationResults = fetchValidationResults;
-exports.processValidationErrors = processValidationErrors;
-exports.displayValidationResults = displayValidationResults;
-const chalk_1 = __importDefault(require("chalk"));
-const marketplaceValidation_1 = require("@hubspot/local-dev-lib/api/marketplaceValidation");
-const logger_1 = require("@hubspot/local-dev-lib/logger");
-const lang_1 = require("./lang");
-const exitCodes_1 = require("./enums/exitCodes");
+import chalk from 'chalk';
+import { requestValidation, getValidationStatus, getValidationResults, } from '@hubspot/local-dev-lib/api/marketplaceValidation';
+import { uiLogger } from './ui/logger.js';
+import { EXIT_CODES } from './enums/exitCodes.js';
 const SLEEP_TIME = 2000;
-async function kickOffValidation(accountId, assetType, src) {
+export async function kickOffValidation(accountId, assetType, src) {
     const requestGroup = 'EXTERNAL_DEVELOPER';
     try {
-        const { data: requestResult } = await (0, marketplaceValidation_1.requestValidation)(accountId, {
+        const { data: requestResult } = await requestValidation(accountId, {
             path: src,
             assetType,
             requestGroup,
@@ -25,14 +14,14 @@ async function kickOffValidation(accountId, assetType, src) {
         return requestResult;
     }
     catch (err) {
-        logger_1.logger.debug(err);
-        process.exit(exitCodes_1.EXIT_CODES.ERROR);
+        uiLogger.debug(err);
+        process.exit(EXIT_CODES.ERROR);
     }
 }
-async function pollForValidationFinish(accountId, validationId) {
+export async function pollForValidationFinish(accountId, validationId) {
     try {
         const checkValidationStatus = async () => {
-            const { data: validationStatus } = await (0, marketplaceValidation_1.getValidationStatus)(accountId, {
+            const { data: validationStatus } = await getValidationStatus(accountId, {
                 validationId,
             });
             if (validationStatus === 'REQUESTED') {
@@ -43,81 +32,75 @@ async function pollForValidationFinish(accountId, validationId) {
         await checkValidationStatus();
     }
     catch (err) {
-        logger_1.logger.debug(err);
-        process.exit(exitCodes_1.EXIT_CODES.ERROR);
+        uiLogger.debug(err);
+        process.exit(EXIT_CODES.ERROR);
     }
 }
-async function fetchValidationResults(accountId, validationId) {
+export async function fetchValidationResults(accountId, validationId) {
     try {
-        const { data: validationResults } = await (0, marketplaceValidation_1.getValidationResults)(accountId, {
+        const { data: validationResults } = await getValidationResults(accountId, {
             validationId,
         });
         return validationResults;
     }
     catch (err) {
-        logger_1.logger.debug(err);
-        process.exit(exitCodes_1.EXIT_CODES.ERROR);
+        uiLogger.debug(err);
+        process.exit(EXIT_CODES.ERROR);
     }
 }
-function processValidationErrors(i18nKey, validationResults) {
+export function processValidationErrors(invalidPathError, validationResults) {
     if (validationResults.errors.length) {
         const { assetPath, errors } = validationResults;
         errors.forEach(err => {
             if (err.failureReasonType === 'DOWNLOAD_EMPTY') {
-                logger_1.logger.error((0, lang_1.i18n)(`${i18nKey}.errors.invalidPath`, {
-                    path: assetPath,
-                }));
+                uiLogger.error(invalidPathError(assetPath));
             }
             else {
-                logger_1.logger.error(`${err.context}`);
+                uiLogger.error(`${err.context}`);
             }
         });
-        process.exit(exitCodes_1.EXIT_CODES.ERROR);
+        process.exit(EXIT_CODES.ERROR);
     }
 }
-function displayFileInfo(file, line, i18nKey) {
+function displayFileInfo(file, line, resultsCopy) {
     if (file) {
-        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.results.warnings.file`, {
-            file,
-        }));
+        uiLogger.log(resultsCopy.warnings.file(file));
     }
     if (line) {
-        logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.results.warnings.lineNumber`, {
-            line,
-        }));
+        uiLogger.log(resultsCopy.warnings.lineNumber(line.toString()));
     }
 }
-function displayResults(checks, i18nKey) {
+function displayResults(checks, resultsCopy) {
     if (checks) {
         const { status, results } = checks;
         if (status === 'FAIL') {
             const failedValidations = results.filter(test => test.status === 'FAIL');
             const warningValidations = results.filter(test => test.status === 'WARN');
             failedValidations.forEach(val => {
-                logger_1.logger.error(`${val.message}`);
-                displayFileInfo(val.file, val.line, i18nKey);
+                uiLogger.error(`${val.message}`);
+                displayFileInfo(val.file, val.line, resultsCopy);
             });
             warningValidations.forEach(val => {
-                logger_1.logger.warn(`${val.message}`);
-                displayFileInfo(val.file, val.line, i18nKey);
+                uiLogger.warn(`${val.message}`);
+                displayFileInfo(val.file, val.line, resultsCopy);
             });
         }
         if (status === 'PASS') {
-            logger_1.logger.success((0, lang_1.i18n)(`${i18nKey}.results.noErrors`));
+            uiLogger.success(resultsCopy.noErrors);
             results.forEach(test => {
                 if (test.status === 'WARN') {
-                    logger_1.logger.warn(`${test.message}`);
-                    displayFileInfo(test.file, test.line, i18nKey);
+                    uiLogger.warn(`${test.message}`);
+                    displayFileInfo(test.file, test.line, resultsCopy);
                 }
             });
         }
     }
     return;
 }
-function displayValidationResults(i18nKey, validationResults) {
+export function displayValidationResults(resultsCopy, validationResults) {
     Object.keys(validationResults.results).forEach(type => {
-        logger_1.logger.log(chalk_1.default.bold((0, lang_1.i18n)(`${i18nKey}.results.${type.toLowerCase()}`)));
-        displayResults(validationResults.results[type], i18nKey);
-        logger_1.logger.log();
+        uiLogger.log(chalk.bold(resultsCopy[type.toLowerCase()]));
+        displayResults(validationResults.results[type], resultsCopy);
+        uiLogger.log('');
     });
 }

package/lib/mcp/setup.d.ts

@@ -0,0 +1,23 @@
+export declare const supportedTools: ({
+    name: "Claude Code";
+    value: string;
+} | {
+    name: "Cursor";
+    value: string;
+} | {
+    name: "Windsurf";
+    value: string;
+} | {
+    name: "VSCode";
+    value: string;
+})[];
+interface McpCommand {
+    command: string;
+    args: string[];
+}
+export declare function addMcpServerToConfig(targets: string[] | undefined): Promise<string[]>;
+export declare function setupVsCode(mcpCommand?: McpCommand): Promise<boolean>;
+export declare function setupClaudeCode(mcpCommand?: McpCommand): Promise<boolean>;
+export declare function setupCursor(mcpCommand?: McpCommand): boolean;
+export declare function setupWindsurf(mcpCommand?: McpCommand): boolean;
+export {};

package/lib/mcp/setup.js

@@ -0,0 +1,238 @@
+import { uiLogger } from '../ui/logger.js';
+import { commands } from '../../lang/en.js';
+import { promptUser } from '../prompts/promptUtils.js';
+import SpinniesManager from '../ui/SpinniesManager.js';
+import { logError } from '../errorHandlers/index.js';
+import { execAsync } from '../../mcp-server/utils/command.js';
+import path from 'path';
+import os from 'os';
+import fs from 'fs-extra';
+import { existsSync } from 'fs';
+const mcpServerName = 'HubSpotDev';
+const claudeCode = 'claude';
+const windsurf = 'windsurf';
+const cursor = 'cursor';
+const vscode = 'vscode';
+export const supportedTools = [
+    { name: commands.mcp.setup.claudeCode, value: claudeCode },
+    { name: commands.mcp.setup.cursor, value: cursor },
+    { name: commands.mcp.setup.windsurf, value: windsurf },
+    { name: commands.mcp.setup.vsCode, value: vscode },
+];
+const defaultMcpCommand = {
+    command: 'hs',
+    args: ['mcp', 'start'],
+};
+export async function addMcpServerToConfig(targets) {
+    try {
+        let derivedTargets = [];
+        if (!targets || targets.length === 0) {
+            const { selectedTargets } = await promptUser({
+                name: 'selectedTargets',
+                type: 'checkbox',
+                message: commands.mcp.setup.prompts.targets,
+                choices: supportedTools,
+                validate: (choices) => {
+                    return choices.length === 0
+                        ? commands.mcp.setup.prompts.targetsRequired
+                        : true;
+                },
+            });
+            derivedTargets = selectedTargets;
+        }
+        else {
+            derivedTargets = targets;
+        }
+        SpinniesManager.init();
+        if (derivedTargets.includes(claudeCode)) {
+            await runSetupFunction(setupClaudeCode);
+        }
+        if (derivedTargets.includes(cursor)) {
+            await runSetupFunction(setupCursor);
+        }
+        if (derivedTargets.includes(windsurf)) {
+            await runSetupFunction(setupWindsurf);
+        }
+        if (derivedTargets.includes(vscode)) {
+            await runSetupFunction(setupVsCode);
+        }
+        uiLogger.info(commands.mcp.setup.success(derivedTargets));
+        return derivedTargets;
+    }
+    catch (error) {
+        SpinniesManager.fail('mcpSetup', {
+            text: commands.mcp.setup.spinners.failedToConfigure,
+        });
+        throw error;
+    }
+}
+async function runSetupFunction(func) {
+    const result = await func();
+    if (!result) {
+        throw new Error();
+    }
+}
+function setupMcpConfigFile(config) {
+    try {
+        SpinniesManager.add('spinner', {
+            text: config.configuringMessage,
+        });
+        if (!existsSync(config.configPath)) {
+            fs.writeFileSync(config.configPath, JSON.stringify({}, null, 2));
+        }
+        let mcpConfig = {};
+        let configContent;
+        try {
+            configContent = fs.readFileSync(config.configPath, 'utf8');
+        }
+        catch (error) {
+            SpinniesManager.fail('spinner', {
+                text: config.failedMessage,
+            });
+            logError(error);
+            return false;
+        }
+        try {
+            // In the event the file exists, but is empty, initialize it to and empty object
+            if (configContent.trim() === '') {
+                mcpConfig = {};
+            }
+            else {
+                mcpConfig = JSON.parse(configContent);
+            }
+        }
+        catch (error) {
+            SpinniesManager.fail('spinner', {
+                text: config.failedMessage,
+            });
+            uiLogger.error(commands.mcp.setup.errors.errorParsingJsonFIle(config.configPath, error instanceof Error ? error.message : `${error}`));
+            return false;
+        }
+        // Initialize mcpServers if it doesn't exist
+        if (!mcpConfig.mcpServers) {
+            mcpConfig.mcpServers = {};
+        }
+        // Add or update HubSpot CLI MCP server
+        mcpConfig.mcpServers[mcpServerName] = {
+            ...config.mcpCommand,
+        };
+        // Write the updated config
+        fs.writeFileSync(config.configPath, JSON.stringify(mcpConfig, null, 2));
+        SpinniesManager.succeed('spinner', {
+            text: config.configuredMessage,
+        });
+        return true;
+    }
+    catch (error) {
+        SpinniesManager.fail('spinner', {
+            text: config.failedMessage,
+        });
+        logError(error);
+        return false;
+    }
+}
+export async function setupVsCode(mcpCommand = defaultMcpCommand) {
+    try {
+        SpinniesManager.add('vsCode', {
+            text: commands.mcp.setup.spinners.configuringVsCode,
+        });
+        const mcpConfig = JSON.stringify({
+            name: mcpServerName,
+            ...buildCommandWithAgentString(mcpCommand, vscode),
+        });
+        await execAsync(`code --add-mcp ${JSON.stringify(mcpConfig)}`);
+        SpinniesManager.succeed('vsCode', {
+            text: commands.mcp.setup.spinners.configuredVsCode,
+        });
+        return true;
+    }
+    catch (error) {
+        if (error instanceof Error &&
+            error.message.includes('code: command not found')) {
+            SpinniesManager.fail('vsCode', {
+                text: commands.mcp.setup.spinners.vsCodeNotFound,
+            });
+        }
+        else {
+            SpinniesManager.fail('vsCode', {
+                text: commands.mcp.setup.spinners.failedToConfigureVsCode,
+            });
+            logError(error);
+        }
+        return false;
+    }
+}
+export async function setupClaudeCode(mcpCommand = defaultMcpCommand) {
+    try {
+        SpinniesManager.add('claudeCode', {
+            text: commands.mcp.setup.spinners.configuringClaudeCode,
+        });
+        try {
+            // Check if claude command is available
+            await execAsync('claude --version');
+            // Run claude mcp add command
+            const mcpConfig = JSON.stringify({
+                type: 'stdio',
+                ...buildCommandWithAgentString(mcpCommand, claudeCode),
+            });
+            const { stdout } = await execAsync('claude mcp list');
+            if (stdout.includes(mcpServerName)) {
+                SpinniesManager.update('claudeCode', {
+                    text: commands.mcp.setup.spinners.alreadyInstalled,
+                });
+                await execAsync(`claude mcp remove "${mcpServerName}" --scope user`);
+            }
+            await execAsync(`claude mcp add-json "${mcpServerName}" ${JSON.stringify(mcpConfig)} --scope user`);
+            SpinniesManager.succeed('claudeCode', {
+                text: commands.mcp.setup.spinners.configuredClaudeCode,
+            });
+            return true;
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('claude')) {
+                SpinniesManager.fail('claudeCode', {
+                    text: commands.mcp.setup.spinners.claudeCodeNotFound,
+                });
+            }
+            else {
+                SpinniesManager.fail('claudeCode', {
+                    text: commands.mcp.setup.spinners.claudeCodeInstallFailed,
+                });
+                logError(error);
+            }
+            return false;
+        }
+    }
+    catch (error) {
+        SpinniesManager.fail('claudeCode', {
+            text: commands.mcp.setup.spinners.claudeCodeInstallFailed,
+        });
+        logError(error);
+        return false;
+    }
+}
+export function setupCursor(mcpCommand = defaultMcpCommand) {
+    const cursorConfigPath = path.join(os.homedir(), '.cursor', 'mcp.json');
+    return setupMcpConfigFile({
+        configPath: cursorConfigPath,
+        configuringMessage: commands.mcp.setup.spinners.configuringCursor,
+        configuredMessage: commands.mcp.setup.spinners.configuredCursor,
+        failedMessage: commands.mcp.setup.spinners.failedToConfigureCursor,
+        mcpCommand: buildCommandWithAgentString(mcpCommand, cursor),
+    });
+}
+export function setupWindsurf(mcpCommand = defaultMcpCommand) {
+    const windsurfConfigPath = path.join(os.homedir(), '.codeium', 'windsurf', 'mcp_config.json');
+    return setupMcpConfigFile({
+        configPath: windsurfConfigPath,
+        configuringMessage: commands.mcp.setup.spinners.configuringWindsurf,
+        configuredMessage: commands.mcp.setup.spinners.configuredWindsurf,
+        failedMessage: commands.mcp.setup.spinners.failedToConfigureWindsurf,
+        mcpCommand: buildCommandWithAgentString(mcpCommand, windsurf),
+    });
+}
+function buildCommandWithAgentString(mcpCommand, agent) {
+    const mcpCommandCopy = structuredClone(mcpCommand);
+    mcpCommandCopy.args.push('--ai-agent', agent);
+    return mcpCommandCopy;
+}