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

package/lib/lang.js

@@ -1,13 +1,18 @@
-import util from 'util';
-import path, { dirname } from 'path';
-import fs from 'fs-extra';
-import yaml from 'js-yaml';
-import { logger } from '@hubspot/local-dev-lib/logger';
-import { interpolate } from './interpolation.js';
-import { fileURLToPath } from 'url';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-export const MISSING_LANGUAGE_DATA_PREFIX = '[Missing language data]';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MISSING_LANGUAGE_DATA_PREFIX = void 0;
+exports.i18n = i18n;
+exports.setLangData = setLangData;
+const util_1 = __importDefault(require("util"));
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+const interpolation_1 = require("./interpolation");
+exports.MISSING_LANGUAGE_DATA_PREFIX = '[Missing language data]';
 let locale;
 let languageObj;
 function loadLanguageFromYaml() {
@@ -17,20 +22,20 @@ function loadLanguageFromYaml() {
         const nodeLocale = Intl.DateTimeFormat()
             .resolvedOptions()
             .locale.split('-')[0];
-        const languageFilePath = path.join(__dirname, `../lang/${nodeLocale}.lyaml`);
-        const languageFileExists = fs.existsSync(languageFilePath);
+        const languageFilePath = path_1.default.join(__dirname, `../lang/${nodeLocale}.lyaml`);
+        const languageFileExists = fs_extra_1.default.existsSync(languageFilePath);
         // Fall back to using the default language file
         locale = languageFileExists ? nodeLocale : 'en';
-        languageObj = yaml.load(fs.readFileSync(path.join(__dirname, `../lang/${locale}.lyaml`), 'utf8'));
-        logger.debug('Loaded language data: ', util.inspect(languageObj, true, 999, true));
+        languageObj = js_yaml_1.default.load(fs_extra_1.default.readFileSync(path_1.default.join(__dirname, `../lang/${locale}.lyaml`), 'utf8'));
+        logger_1.logger.debug('Loaded language data: ', util_1.default.inspect(languageObj, true, 999, true));
     }
     catch (e) {
-        logger.error('Error loading language data: ', e);
+        logger_1.logger.error('Error loading language data: ', e);
     }
 }
 function getTextValue(lookupDotNotation) {
     const lookupProps = [locale, ...lookupDotNotation.split('.')];
-    const missingTextData = `${MISSING_LANGUAGE_DATA_PREFIX}: ${lookupProps.join('.')}`;
+    const missingTextData = `${exports.MISSING_LANGUAGE_DATA_PREFIX}: ${lookupProps.join('.')}`;
     let textValue = languageObj;
     let previouslyCheckedProp = lookupProps[0];
     try {
@@ -42,8 +47,8 @@ function getTextValue(lookupDotNotation) {
         });
     }
     catch (e) {
-        logger.debug(`Unable to access language property: ${lookupProps.join('.')}. Failed to access prop "${previouslyCheckedProp}".`);
-        logger.error('Unable to access language property.');
+        logger_1.logger.debug(`Unable to access language property: ${lookupProps.join('.')}. Failed to access prop "${previouslyCheckedProp}".`);
+        logger_1.logger.error('Unable to access language property.');
         return missingTextData;
     }
     if (!textValue) {
@@ -54,7 +59,7 @@ function getTextValue(lookupDotNotation) {
     }
     return textValue;
 }
-export function i18n(lookupDotNotation, options = {}) {
+function i18n(lookupDotNotation, options = {}) {
     if (!languageObj) {
         loadLanguageFromYaml();
     }
@@ -62,10 +67,10 @@ export function i18n(lookupDotNotation, options = {}) {
         throw new Error(`i18n must be passed a string value for lookupDotNotation, received ${typeof lookupDotNotation}`);
     }
     const textValue = getTextValue(lookupDotNotation);
-    const shouldInterpolate = !textValue.startsWith(MISSING_LANGUAGE_DATA_PREFIX);
-    return shouldInterpolate ? interpolate(textValue, options) : textValue;
+    const shouldInterpolate = !textValue.startsWith(exports.MISSING_LANGUAGE_DATA_PREFIX);
+    return shouldInterpolate ? (0, interpolation_1.interpolate)(textValue, options) : textValue;
 }
-export function setLangData(newLocale, newLangObj) {
+function setLangData(newLocale, newLangObj) {
     locale = newLocale;
     languageObj = newLangObj;
 }

package/lib/links.js

@@ -1,9 +1,17 @@
-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';
+"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 = {
     APPS_MARKETPLACE: {
         shortcut: 'apps-marketplace',
@@ -74,28 +82,28 @@ const SITE_LINKS = {
         getUrl: (accountId, baseUrl) => `${baseUrl}/website/${accountId}/pages/site`,
     },
 };
-export function getSiteLinksAsArray(accountId) {
-    const baseUrl = getHubSpotWebsiteOrigin(getEnv() === 'qa' ? ENVIRONMENTS.QA : ENVIRONMENTS.PROD);
+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)
         .sort((a, b) => (a.shortcut < b.shortcut ? -1 : 1))
         .map(l => ({ ...l, url: l.getUrl(accountId, baseUrl) }));
 }
-export function logSiteLinks(accountId) {
+function logSiteLinks(accountId) {
     const linksAsArray = getSiteLinksAsArray(accountId).map(l => [
         `${l.shortcut}${l.alias ? ` [alias: ${l.alias}]` : ''}`,
         '=>',
         l.url,
     ]);
-    linksAsArray.unshift(getTableHeader(['Shortcut', '', 'Url']));
-    logger.log(getTableContents(linksAsArray));
+    linksAsArray.unshift((0, table_1.getTableHeader)(['Shortcut', '', 'Url']));
+    logger_1.logger.log((0, table_1.getTableContents)(linksAsArray));
 }
-export function openLink(accountId, shortcut) {
+function openLink(accountId, shortcut) {
     const match = Object.values(SITE_LINKS).find(l => l.shortcut === shortcut || (l.alias && l.alias === shortcut));
     if (!match) {
-        logger.error(`We couldn't find a shortcut matching ${shortcut}.  Type 'hs open list' to see a list of available shortcuts`);
+        logger_1.logger.error(`We couldn't find a shortcut matching ${shortcut}.  Type 'hs open list' to see a list of available shortcuts`);
         return;
     }
-    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`);
+    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`);
 }

package/lib/marketplaceValidate.js

@@ -1,12 +1,22 @@
-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';
+"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("./ui/logger");
+const exitCodes_1 = require("./enums/exitCodes");
 const SLEEP_TIME = 2000;
-export async function kickOffValidation(accountId, assetType, src) {
+async function kickOffValidation(accountId, assetType, src) {
     const requestGroup = 'EXTERNAL_DEVELOPER';
     try {
-        const { data: requestResult } = await requestValidation(accountId, {
+        const { data: requestResult } = await (0, marketplaceValidation_1.requestValidation)(accountId, {
             path: src,
             assetType,
             requestGroup,
@@ -14,14 +24,14 @@ export async function kickOffValidation(accountId, assetType, src) {
         return requestResult;
     }
     catch (err) {
-        uiLogger.debug(err);
-        process.exit(EXIT_CODES.ERROR);
+        logger_1.uiLogger.debug(err);
+        process.exit(exitCodes_1.EXIT_CODES.ERROR);
     }
 }
-export async function pollForValidationFinish(accountId, validationId) {
+async function pollForValidationFinish(accountId, validationId) {
     try {
         const checkValidationStatus = async () => {
-            const { data: validationStatus } = await getValidationStatus(accountId, {
+            const { data: validationStatus } = await (0, marketplaceValidation_1.getValidationStatus)(accountId, {
                 validationId,
             });
             if (validationStatus === 'REQUESTED') {
@@ -32,42 +42,42 @@ export async function pollForValidationFinish(accountId, validationId) {
         await checkValidationStatus();
     }
     catch (err) {
-        uiLogger.debug(err);
-        process.exit(EXIT_CODES.ERROR);
+        logger_1.uiLogger.debug(err);
+        process.exit(exitCodes_1.EXIT_CODES.ERROR);
     }
 }
-export async function fetchValidationResults(accountId, validationId) {
+async function fetchValidationResults(accountId, validationId) {
     try {
-        const { data: validationResults } = await getValidationResults(accountId, {
+        const { data: validationResults } = await (0, marketplaceValidation_1.getValidationResults)(accountId, {
             validationId,
         });
         return validationResults;
     }
     catch (err) {
-        uiLogger.debug(err);
-        process.exit(EXIT_CODES.ERROR);
+        logger_1.uiLogger.debug(err);
+        process.exit(exitCodes_1.EXIT_CODES.ERROR);
     }
 }
-export function processValidationErrors(invalidPathError, validationResults) {
+function processValidationErrors(invalidPathError, validationResults) {
     if (validationResults.errors.length) {
         const { assetPath, errors } = validationResults;
         errors.forEach(err => {
             if (err.failureReasonType === 'DOWNLOAD_EMPTY') {
-                uiLogger.error(invalidPathError(assetPath));
+                logger_1.uiLogger.error(invalidPathError(assetPath));
             }
             else {
-                uiLogger.error(`${err.context}`);
+                logger_1.uiLogger.error(`${err.context}`);
             }
         });
-        process.exit(EXIT_CODES.ERROR);
+        process.exit(exitCodes_1.EXIT_CODES.ERROR);
     }
 }
 function displayFileInfo(file, line, resultsCopy) {
     if (file) {
-        uiLogger.log(resultsCopy.warnings.file(file));
+        logger_1.uiLogger.log(resultsCopy.warnings.file(file));
     }
     if (line) {
-        uiLogger.log(resultsCopy.warnings.lineNumber(line.toString()));
+        logger_1.uiLogger.log(resultsCopy.warnings.lineNumber(line.toString()));
     }
 }
 function displayResults(checks, resultsCopy) {
@@ -77,19 +87,19 @@ function displayResults(checks, resultsCopy) {
             const failedValidations = results.filter(test => test.status === 'FAIL');
             const warningValidations = results.filter(test => test.status === 'WARN');
             failedValidations.forEach(val => {
-                uiLogger.error(`${val.message}`);
+                logger_1.uiLogger.error(`${val.message}`);
                 displayFileInfo(val.file, val.line, resultsCopy);
             });
             warningValidations.forEach(val => {
-                uiLogger.warn(`${val.message}`);
+                logger_1.uiLogger.warn(`${val.message}`);
                 displayFileInfo(val.file, val.line, resultsCopy);
             });
         }
         if (status === 'PASS') {
-            uiLogger.success(resultsCopy.noErrors);
+            logger_1.uiLogger.success(resultsCopy.noErrors);
             results.forEach(test => {
                 if (test.status === 'WARN') {
-                    uiLogger.warn(`${test.message}`);
+                    logger_1.uiLogger.warn(`${test.message}`);
                     displayFileInfo(test.file, test.line, resultsCopy);
                 }
             });
@@ -97,10 +107,10 @@ function displayResults(checks, resultsCopy) {
     }
     return;
 }
-export function displayValidationResults(resultsCopy, validationResults) {
+function displayValidationResults(resultsCopy, validationResults) {
     Object.keys(validationResults.results).forEach(type => {
-        uiLogger.log(chalk.bold(resultsCopy[type.toLowerCase()]));
+        logger_1.uiLogger.log(chalk_1.default.bold(resultsCopy[type.toLowerCase()]));
         displayResults(validationResults.results[type], resultsCopy);
-        uiLogger.log('');
+        logger_1.uiLogger.log('');
     });
 }

package/lib/mcp/setup.js

@@ -1,38 +1,50 @@
-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 { spawn } from 'node:child_process';
-import path from 'path';
-import os from 'os';
-import fs from 'fs-extra';
-import { existsSync } from 'fs';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.supportedTools = void 0;
+exports.addMintlifyMcpServer = addMintlifyMcpServer;
+exports.setupMintlify = setupMintlify;
+exports.addMcpServerToConfig = addMcpServerToConfig;
+exports.setupClaudeCode = setupClaudeCode;
+exports.setupCursor = setupCursor;
+exports.setupWindsurf = setupWindsurf;
+const logger_1 = require("../ui/logger");
+const en_1 = require("../../lang/en");
+const promptUtils_1 = require("../prompts/promptUtils");
+const SpinniesManager_1 = __importDefault(require("../ui/SpinniesManager"));
+const errorHandlers_1 = require("../errorHandlers");
+const command_1 = require("../../mcp-server/utils/command");
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const fs_1 = require("fs");
 const mcpServerName = 'hubspot-cli-mcp';
 const claudeCode = 'claude';
 const windsurf = 'windsurf';
 const cursor = 'cursor';
 const supportedMintlifyClients = [windsurf, cursor];
-export const supportedTools = [
-    { name: commands.mcp.setup.claudeCode, value: claudeCode },
-    { name: commands.mcp.setup.cursor, value: cursor },
-    { name: commands.mcp.setup.windsurf, value: windsurf },
+exports.supportedTools = [
+    { name: en_1.commands.mcp.setup.claudeCode, value: claudeCode },
+    { name: en_1.commands.mcp.setup.cursor, value: cursor },
+    { name: en_1.commands.mcp.setup.windsurf, value: windsurf },
 ];
 const defaultMcpCommand = {
     command: 'hs',
     args: ['mcp', 'start'],
 };
-export async function addMintlifyMcpServer(installTargets) {
+async function addMintlifyMcpServer(installTargets) {
     await runSetupFunction(() => setupMintlify(installTargets));
 }
-export async function setupMintlify(derivedTargets = supportedMintlifyClients) {
-    uiLogger.info(commands.mcp.setup.installingDocSearch);
-    uiLogger.log('');
+async function setupMintlify(derivedTargets = supportedMintlifyClients) {
+    logger_1.uiLogger.info(en_1.commands.mcp.setup.installingDocSearch);
+    logger_1.uiLogger.log('');
     return new Promise(resolve => {
         const subcommands = ['mint-mcp', 'add', 'hubspot-migration'];
         const docsSearchClients = derivedTargets.filter(target => supportedMintlifyClients.includes(target));
-        const childProcess = spawn(`npx`, docsSearchClients && docsSearchClients.length
+        const childProcess = (0, child_process_1.spawn)(`npx`, docsSearchClients && docsSearchClients.length
             ? [...subcommands, '--client', ...docsSearchClients]
             : subcommands, {
             stdio: 'inherit',
@@ -45,18 +57,18 @@ export async function setupMintlify(derivedTargets = supportedMintlifyClients) {
         });
     });
 }
-export async function addMcpServerToConfig(targets) {
+async function addMcpServerToConfig(targets) {
     try {
         let derivedTargets = [];
         if (!targets || targets.length === 0) {
-            const { selectedTargets } = await promptUser({
+            const { selectedTargets } = await (0, promptUtils_1.promptUser)({
                 name: 'selectedTargets',
                 type: 'checkbox',
-                message: commands.mcp.setup.prompts.targets,
-                choices: supportedTools,
+                message: en_1.commands.mcp.setup.prompts.targets,
+                choices: exports.supportedTools,
                 validate: (choices) => {
                     return choices.length === 0
-                        ? commands.mcp.setup.prompts.targetsRequired
+                        ? en_1.commands.mcp.setup.prompts.targetsRequired
                         : true;
                 },
             });
@@ -65,7 +77,7 @@ export async function addMcpServerToConfig(targets) {
         else {
             derivedTargets = targets;
         }
-        SpinniesManager.init();
+        SpinniesManager_1.default.init();
         if (derivedTargets.includes(claudeCode)) {
             await runSetupFunction(setupClaudeCode);
         }
@@ -75,12 +87,12 @@ export async function addMcpServerToConfig(targets) {
         if (derivedTargets.includes(windsurf)) {
             await runSetupFunction(setupWindsurf);
         }
-        uiLogger.info(commands.mcp.setup.success(derivedTargets));
+        logger_1.uiLogger.info(en_1.commands.mcp.setup.success(derivedTargets));
         return derivedTargets;
     }
     catch (error) {
-        SpinniesManager.fail('mcpSetup', {
-            text: commands.mcp.setup.spinners.failedToConfigure,
+        SpinniesManager_1.default.fail('mcpSetup', {
+            text: en_1.commands.mcp.setup.spinners.failedToConfigure,
         });
         throw error;
     }
@@ -93,22 +105,38 @@ async function runSetupFunction(func) {
 }
 function setupMcpConfigFile(config) {
     try {
-        SpinniesManager.add('spinner', {
+        SpinniesManager_1.default.add('spinner', {
             text: config.configuringMessage,
         });
-        if (!existsSync(config.configPath)) {
-            fs.writeFileSync(config.configPath, JSON.stringify({}, null, 2));
+        if (!(0, fs_1.existsSync)(config.configPath)) {
+            fs_extra_1.default.writeFileSync(config.configPath, JSON.stringify({}, null, 2));
         }
         let mcpConfig = {};
+        let configContent;
+        try {
+            configContent = fs_extra_1.default.readFileSync(config.configPath, 'utf8');
+        }
+        catch (error) {
+            SpinniesManager_1.default.fail('spinner', {
+                text: config.failedMessage,
+            });
+            (0, errorHandlers_1.logError)(error);
+            return false;
+        }
         try {
-            const configContent = fs.readFileSync(config.configPath, 'utf8');
-            mcpConfig = JSON.parse(configContent);
+            // 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', {
+            SpinniesManager_1.default.fail('spinner', {
                 text: config.failedMessage,
             });
-            logError(error);
+            logger_1.uiLogger.error(en_1.commands.mcp.setup.errors.errorParsingJsonFIle(config.configPath, error instanceof Error ? error.message : `${error}`));
             return false;
         }
         // Initialize mcpServers if it doesn't exist
@@ -120,87 +148,92 @@ function setupMcpConfigFile(config) {
             ...config.mcpCommand,
         };
         // Write the updated config
-        fs.writeFileSync(config.configPath, JSON.stringify(mcpConfig, null, 2));
-        SpinniesManager.succeed('spinner', {
+        fs_extra_1.default.writeFileSync(config.configPath, JSON.stringify(mcpConfig, null, 2));
+        SpinniesManager_1.default.succeed('spinner', {
             text: config.configuredMessage,
         });
         return true;
     }
     catch (error) {
-        SpinniesManager.fail('spinner', {
+        SpinniesManager_1.default.fail('spinner', {
             text: config.failedMessage,
         });
-        logError(error);
+        (0, errorHandlers_1.logError)(error);
         return false;
     }
 }
-export async function setupClaudeCode(mcpCommand = defaultMcpCommand) {
+async function setupClaudeCode(mcpCommand = defaultMcpCommand) {
     try {
-        SpinniesManager.add('claudeCode', {
-            text: commands.mcp.setup.spinners.configuringClaudeCode,
+        SpinniesManager_1.default.add('claudeCode', {
+            text: en_1.commands.mcp.setup.spinners.configuringClaudeCode,
         });
         try {
             // Check if claude command is available
-            await execAsync('claude --version');
+            await (0, command_1.execAsync)('claude --version');
             // Run claude mcp add command
             const mcpConfig = JSON.stringify({
                 type: 'stdio',
-                ...mcpCommand,
+                ...buildCommandWithAgentString(mcpCommand, claudeCode),
             });
-            const { stdout } = await execAsync('claude mcp list');
+            const { stdout } = await (0, command_1.execAsync)('claude mcp list');
             if (stdout.includes(mcpServerName)) {
-                SpinniesManager.update('claudeCode', {
-                    text: commands.mcp.setup.spinners.alreadyInstalled,
+                SpinniesManager_1.default.update('claudeCode', {
+                    text: en_1.commands.mcp.setup.spinners.alreadyInstalled,
                 });
-                await execAsync(`claude mcp remove "${mcpServerName}" --scope user`);
+                await (0, command_1.execAsync)(`claude mcp remove "${mcpServerName}" --scope user`);
             }
-            await execAsync(`claude mcp add-json "${mcpServerName}" '${mcpConfig}' --scope user`);
-            SpinniesManager.succeed('claudeCode', {
-                text: commands.mcp.setup.spinners.configuredClaudeCode,
+            await (0, command_1.execAsync)(`claude mcp add-json "${mcpServerName}" '${mcpConfig}' --scope user`);
+            SpinniesManager_1.default.succeed('claudeCode', {
+                text: en_1.commands.mcp.setup.spinners.configuredClaudeCode,
             });
             return true;
         }
         catch (error) {
             if (error instanceof Error &&
                 error.message.includes('claude: command not found')) {
-                SpinniesManager.fail('claudeCode', {
-                    text: commands.mcp.setup.spinners.claudeCodeNotFound,
+                SpinniesManager_1.default.fail('claudeCode', {
+                    text: en_1.commands.mcp.setup.spinners.claudeCodeNotFound,
                 });
             }
             else {
-                SpinniesManager.fail('claudeCode', {
-                    text: commands.mcp.setup.spinners.claudeCodeInstallFailed,
+                SpinniesManager_1.default.fail('claudeCode', {
+                    text: en_1.commands.mcp.setup.spinners.claudeCodeInstallFailed,
                 });
-                logError(error);
+                (0, errorHandlers_1.logError)(error);
             }
             return false;
         }
     }
     catch (error) {
-        SpinniesManager.fail('claudeCode', {
-            text: commands.mcp.setup.spinners.claudeCodeInstallFailed,
+        SpinniesManager_1.default.fail('claudeCode', {
+            text: en_1.commands.mcp.setup.spinners.claudeCodeInstallFailed,
         });
-        logError(error);
+        (0, errorHandlers_1.logError)(error);
         return false;
     }
 }
-export function setupCursor(mcpCommand = defaultMcpCommand) {
-    const cursorConfigPath = path.join(os.homedir(), '.cursor', 'mcp.json');
+function setupCursor(mcpCommand = defaultMcpCommand) {
+    const cursorConfigPath = path_1.default.join(os_1.default.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,
+        configuringMessage: en_1.commands.mcp.setup.spinners.configuringCursor,
+        configuredMessage: en_1.commands.mcp.setup.spinners.configuredCursor,
+        failedMessage: en_1.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');
+function setupWindsurf(mcpCommand = defaultMcpCommand) {
+    const windsurfConfigPath = path_1.default.join(os_1.default.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,
+        configuringMessage: en_1.commands.mcp.setup.spinners.configuringWindsurf,
+        configuredMessage: en_1.commands.mcp.setup.spinners.configuredWindsurf,
+        failedMessage: en_1.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;
+}