@hubspot/cli 7.6.0-beta.0 → 7.6.0-beta.10

package/lib/links.js

@@ -1,17 +1,9 @@
-"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");
+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 SITE_LINKS = {
     APPS_MARKETPLACE: {
         shortcut: 'apps-marketplace',
@@ -82,28 +74,28 @@ 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);
+export function getSiteLinksAsArray(accountId) {
+    const baseUrl = getHubSpotWebsiteOrigin(getEnv() === 'qa' ? ENVIRONMENTS.QA : ENVIRONMENTS.PROD);
     return Object.values(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) {
+export function openLink(accountId, shortcut) {
     const match = Object.values(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`);
 }

package/lib/marketplaceValidate.js

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

package/lib/mcp/setup.d.ts

@@ -7,6 +7,9 @@ export declare const supportedTools: ({
 } | {
     name: "Windsurf";
     value: string;
+} | {
+    name: "VSCode";
+    value: string;
 })[];
 interface McpCommand {
     command: string;
@@ -15,6 +18,7 @@ interface McpCommand {
 export declare function addMintlifyMcpServer(installTargets: string[]): Promise<void>;
 export declare function setupMintlify(derivedTargets?: string[]): Promise<boolean>;
 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;

package/lib/mcp/setup.js

@@ -1,50 +1,40 @@
-"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");
+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';
 const mcpServerName = 'hubspot-cli-mcp';
 const claudeCode = 'claude';
 const windsurf = 'windsurf';
 const cursor = 'cursor';
+const vscode = 'vscode';
 const supportedMintlifyClients = [windsurf, cursor];
-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 },
+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'],
 };
-async function addMintlifyMcpServer(installTargets) {
+export async function addMintlifyMcpServer(installTargets) {
     await runSetupFunction(() => setupMintlify(installTargets));
 }
-async function setupMintlify(derivedTargets = supportedMintlifyClients) {
-    logger_1.uiLogger.info(en_1.commands.mcp.setup.installingDocSearch);
-    logger_1.uiLogger.log('');
+export async function setupMintlify(derivedTargets = supportedMintlifyClients) {
+    uiLogger.info(commands.mcp.setup.installingDocSearch);
+    uiLogger.log('');
     return new Promise(resolve => {
         const subcommands = ['mint-mcp', 'add', 'hubspot-migration'];
         const docsSearchClients = derivedTargets.filter(target => supportedMintlifyClients.includes(target));
-        const childProcess = (0, child_process_1.spawn)(`npx`, docsSearchClients && docsSearchClients.length
+        const childProcess = spawn(`npx`, docsSearchClients && docsSearchClients.length
             ? [...subcommands, '--client', ...docsSearchClients]
             : subcommands, {
             stdio: 'inherit',
@@ -57,18 +47,18 @@ async function setupMintlify(derivedTargets = supportedMintlifyClients) {
         });
     });
 }
-async function addMcpServerToConfig(targets) {
+export async function addMcpServerToConfig(targets) {
     try {
         let derivedTargets = [];
         if (!targets || targets.length === 0) {
-            const { selectedTargets } = await (0, promptUtils_1.promptUser)({
+            const { selectedTargets } = await promptUser({
                 name: 'selectedTargets',
                 type: 'checkbox',
-                message: en_1.commands.mcp.setup.prompts.targets,
-                choices: exports.supportedTools,
+                message: commands.mcp.setup.prompts.targets,
+                choices: supportedTools,
                 validate: (choices) => {
                     return choices.length === 0
-                        ? en_1.commands.mcp.setup.prompts.targetsRequired
+                        ? commands.mcp.setup.prompts.targetsRequired
                         : true;
                 },
             });
@@ -77,7 +67,7 @@ async function addMcpServerToConfig(targets) {
         else {
             derivedTargets = targets;
         }
-        SpinniesManager_1.default.init();
+        SpinniesManager.init();
         if (derivedTargets.includes(claudeCode)) {
             await runSetupFunction(setupClaudeCode);
         }
@@ -87,12 +77,15 @@ async function addMcpServerToConfig(targets) {
         if (derivedTargets.includes(windsurf)) {
             await runSetupFunction(setupWindsurf);
         }
-        logger_1.uiLogger.info(en_1.commands.mcp.setup.success(derivedTargets));
+        if (derivedTargets.includes(vscode)) {
+            await runSetupFunction(setupVsCode);
+        }
+        uiLogger.info(commands.mcp.setup.success(derivedTargets));
         return derivedTargets;
     }
     catch (error) {
-        SpinniesManager_1.default.fail('mcpSetup', {
-            text: en_1.commands.mcp.setup.spinners.failedToConfigure,
+        SpinniesManager.fail('mcpSetup', {
+            text: commands.mcp.setup.spinners.failedToConfigure,
         });
         throw error;
     }
@@ -105,22 +98,38 @@ async function runSetupFunction(func) {
 }
 function setupMcpConfigFile(config) {
     try {
-        SpinniesManager_1.default.add('spinner', {
+        SpinniesManager.add('spinner', {
             text: config.configuringMessage,
         });
-        if (!(0, fs_1.existsSync)(config.configPath)) {
-            fs_extra_1.default.writeFileSync(config.configPath, JSON.stringify({}, null, 2));
+        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 {
-            const configContent = fs_extra_1.default.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_1.default.fail('spinner', {
+            SpinniesManager.fail('spinner', {
                 text: config.failedMessage,
             });
-            (0, errorHandlers_1.logError)(error);
+            uiLogger.error(commands.mcp.setup.errors.errorParsingJsonFIle(config.configPath, error instanceof Error ? error.message : `${error}`));
             return false;
         }
         // Initialize mcpServers if it doesn't exist
@@ -132,87 +141,123 @@ function setupMcpConfigFile(config) {
             ...config.mcpCommand,
         };
         // Write the updated config
-        fs_extra_1.default.writeFileSync(config.configPath, JSON.stringify(mcpConfig, null, 2));
-        SpinniesManager_1.default.succeed('spinner', {
+        fs.writeFileSync(config.configPath, JSON.stringify(mcpConfig, null, 2));
+        SpinniesManager.succeed('spinner', {
             text: config.configuredMessage,
         });
         return true;
     }
     catch (error) {
-        SpinniesManager_1.default.fail('spinner', {
+        SpinniesManager.fail('spinner', {
             text: config.failedMessage,
         });
-        (0, errorHandlers_1.logError)(error);
+        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 '${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;
     }
 }
-async function setupClaudeCode(mcpCommand = defaultMcpCommand) {
+export async function setupClaudeCode(mcpCommand = defaultMcpCommand) {
     try {
-        SpinniesManager_1.default.add('claudeCode', {
-            text: en_1.commands.mcp.setup.spinners.configuringClaudeCode,
+        SpinniesManager.add('claudeCode', {
+            text: commands.mcp.setup.spinners.configuringClaudeCode,
         });
         try {
             // Check if claude command is available
-            await (0, command_1.execAsync)('claude --version');
+            await execAsync('claude --version');
             // Run claude mcp add command
             const mcpConfig = JSON.stringify({
                 type: 'stdio',
-                ...mcpCommand,
+                ...buildCommandWithAgentString(mcpCommand, claudeCode),
             });
-            const { stdout } = await (0, command_1.execAsync)('claude mcp list');
+            const { stdout } = await execAsync('claude mcp list');
             if (stdout.includes(mcpServerName)) {
-                SpinniesManager_1.default.update('claudeCode', {
-                    text: en_1.commands.mcp.setup.spinners.alreadyInstalled,
+                SpinniesManager.update('claudeCode', {
+                    text: commands.mcp.setup.spinners.alreadyInstalled,
                 });
-                await (0, command_1.execAsync)(`claude mcp remove "${mcpServerName}" --scope user`);
+                await execAsync(`claude mcp remove "${mcpServerName}" --scope user`);
             }
-            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,
+            await execAsync(`claude mcp add-json "${mcpServerName}" '${mcpConfig}' --scope user`);
+            SpinniesManager.succeed('claudeCode', {
+                text: commands.mcp.setup.spinners.configuredClaudeCode,
             });
             return true;
         }
         catch (error) {
             if (error instanceof Error &&
                 error.message.includes('claude: command not found')) {
-                SpinniesManager_1.default.fail('claudeCode', {
-                    text: en_1.commands.mcp.setup.spinners.claudeCodeNotFound,
+                SpinniesManager.fail('claudeCode', {
+                    text: commands.mcp.setup.spinners.claudeCodeNotFound,
                 });
             }
             else {
-                SpinniesManager_1.default.fail('claudeCode', {
-                    text: en_1.commands.mcp.setup.spinners.claudeCodeInstallFailed,
+                SpinniesManager.fail('claudeCode', {
+                    text: commands.mcp.setup.spinners.claudeCodeInstallFailed,
                 });
-                (0, errorHandlers_1.logError)(error);
+                logError(error);
             }
             return false;
         }
     }
     catch (error) {
-        SpinniesManager_1.default.fail('claudeCode', {
-            text: en_1.commands.mcp.setup.spinners.claudeCodeInstallFailed,
+        SpinniesManager.fail('claudeCode', {
+            text: commands.mcp.setup.spinners.claudeCodeInstallFailed,
         });
-        (0, errorHandlers_1.logError)(error);
+        logError(error);
         return false;
     }
 }
-function setupCursor(mcpCommand = defaultMcpCommand) {
-    const cursorConfigPath = path_1.default.join(os_1.default.homedir(), '.cursor', 'mcp.json');
+export function setupCursor(mcpCommand = defaultMcpCommand) {
+    const cursorConfigPath = path.join(os.homedir(), '.cursor', 'mcp.json');
     return setupMcpConfigFile({
         configPath: cursorConfigPath,
-        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,
+        configuringMessage: commands.mcp.setup.spinners.configuringCursor,
+        configuredMessage: commands.mcp.setup.spinners.configuredCursor,
+        failedMessage: commands.mcp.setup.spinners.failedToConfigureCursor,
+        mcpCommand: buildCommandWithAgentString(mcpCommand, cursor),
     });
 }
-function setupWindsurf(mcpCommand = defaultMcpCommand) {
-    const windsurfConfigPath = path_1.default.join(os_1.default.homedir(), '.codeium', 'windsurf', 'mcp_config.json');
+export function setupWindsurf(mcpCommand = defaultMcpCommand) {
+    const windsurfConfigPath = path.join(os.homedir(), '.codeium', 'windsurf', 'mcp_config.json');
     return setupMcpConfigFile({
         configPath: windsurfConfigPath,
-        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,
+        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;
+}