mcp servers working

Author: Eric Oliver

src/cli/cli-entry.ts

@@ -283,6 +283,34 @@ program
 				console.log()
 			}
 
+			// Initialize MCP service if auto-connect is enabled
+			if (options.mcpAutoConnect) {
+				try {
+					getCLILogger().debug("[cli-entry] Initializing GlobalCLIMcpService...")
+					const { GlobalCLIMcpService } = await import("./services/GlobalCLIMcpService")
+					const globalMcpService = GlobalCLIMcpService.getInstance()
+
+					// Initialize with MCP-specific options
+					await globalMcpService.initialize({
+						mcpConfigPath: options.mcpConfig,
+						mcpAutoConnect: options.mcpAutoConnect,
+						mcpTimeout: options.mcpTimeout,
+						mcpRetries: options.mcpRetries,
+					})
+					getCLILogger().debug("[cli-entry] GlobalCLIMcpService initialized successfully")
+				} catch (error) {
+					getCLILogger().debug("[cli-entry] Failed to initialize GlobalCLIMcpService:", error)
+					if (options.verbose) {
+						console.warn(
+							chalk.yellow("Warning: MCP initialization failed:"),
+							error instanceof Error ? error.message : String(error),
+						)
+					}
+				}
+			} else {
+				getCLILogger().debug("[cli-entry] MCP auto-connect disabled, skipping MCP initialization")
+			}
+
 			// Pass configuration to processors
 			if (options.batch || options.stdin || !options.interactive) {
 				// Use NonInteractiveModeService for non-interactive operations

src/cli/index.ts

@@ -171,9 +171,13 @@ program
 	.option("--no-mcp-auto-connect", "Do not automatically connect to enabled MCP servers")
 	.option("--mcp-log-level <level>", "MCP logging level (error, warn, info, debug)", validateMcpLogLevel)
 	.action(async (options: CliOptions) => {
+		console.log("[DEBUG] CLI: Entered main action with options:", JSON.stringify(options, null, 2))
+
 		// Initialize CLI logger first
 		const logger = initializeCLILogger(options.verbose, options.quiet, options.color)
 
+		console.log("[DEBUG] CLI: Logger initialized")
+
 		// Set up graceful shutdown handlers
 		let isShuttingDown = false
 		const gracefulShutdown = async (signal: string) => {
@@ -235,21 +239,35 @@ program
 		await PlatformServiceFactory.initialize(PlatformContext.CLI, "roo-cline", options.config)
 
 		// Initialize global MCP service once at startup
+		console.log(
+			"[DEBUG] CLI: MCP auto-connect check:",
+			options.mcpAutoConnect,
+			"!== false =",
+			options.mcpAutoConnect !== false,
+		)
 		if (options.mcpAutoConnect !== false) {
+			console.log("[DEBUG] CLI: About to initialize global MCP service...")
 			try {
+				const { GlobalCLIMcpService } = await import("./services/GlobalCLIMcpService")
+				console.log("[DEBUG] CLI: GlobalCLIMcpService imported successfully")
 				const globalMcpService = GlobalCLIMcpService.getInstance()
+				console.log("[DEBUG] CLI: GlobalCLIMcpService instance obtained")
 				await globalMcpService.initialize({
 					mcpConfigPath: options.mcpConfig,
 					mcpAutoConnect: options.mcpAutoConnect,
 					mcpTimeout: options.mcpTimeout,
 					mcpRetries: options.mcpRetries,
 				})
+				console.log("[DEBUG] CLI: GlobalCLIMcpService.initialize() completed")
 				if (options.verbose) {
 					logger.debug("Global MCP service initialized successfully")
 				}
 			} catch (error) {
+				console.error("[DEBUG] CLI: Failed to initialize global MCP service:", error)
 				logger.warn("Failed to initialize global MCP service:", error)
 			}
+		} else {
+			console.log("[DEBUG] CLI: MCP auto-connect disabled, skipping MCP initialization")
 		}
 
 		// Handle MCP auto-connect logic: default to true, but allow explicit override

src/cli/services/GlobalCLIMcpService.ts

@@ -55,16 +55,27 @@ class GlobalCLIMcpService {
 		const logger = getCLILogger()
 
 		try {
+			console.log("[GlobalCLIMcpService] DEBUG: Starting MCP service initialization...")
+			console.log("[GlobalCLIMcpService] DEBUG: Config path:", this.configPath || "undefined")
+			console.log("[GlobalCLIMcpService] DEBUG: Auto-connect:", this.mcpAutoConnect)
+
 			logger.debug("[GlobalCLIMcpService] Initializing MCP service...")
 
 			this.mcpService = new CLIMcpService(this.configPath)
 
 			// Load and connect to configured servers
+			console.log("[GlobalCLIMcpService] DEBUG: About to load server configs...")
 			const serverConfigs = await this.mcpService.loadServerConfigs()
 			console.log(`Loading Roo Code MCP configuration from: ${this.configPath || "default locations"}`)
 			console.log(`Found ${serverConfigs.length} enabled MCP servers`)
 
+			// Debug: log server details
+			serverConfigs.forEach((config) => {
+				console.log(`  - Server: ${config.name} (${config.id}) - enabled: ${config.enabled !== false}`)
+			})
+
 			if (this.mcpAutoConnect && serverConfigs.length > 0) {
+				console.log("[GlobalCLIMcpService] DEBUG: Starting server connections...")
 				for (const config of serverConfigs) {
 					try {
 						console.log(`CLI MCP: Connecting to server ${config.name}...`)
@@ -75,12 +86,17 @@ class GlobalCLIMcpService {
 					}
 				}
 			} else if (!this.mcpAutoConnect) {
+				console.log("[GlobalCLIMcpService] DEBUG: Auto-connect disabled, servers loaded but not connected")
 				logger.debug("CLI MCP: Auto-connect disabled, servers loaded but not connected")
+			} else {
+				console.log("[GlobalCLIMcpService] DEBUG: No servers to connect to")
 			}
 
 			this.initialized = true
+			console.log("[GlobalCLIMcpService] DEBUG: MCP service initialization completed successfully")
 			logger.debug("[GlobalCLIMcpService] MCP service initialized successfully")
 		} catch (error) {
+			console.error("[GlobalCLIMcpService] ERROR: Failed to initialize MCP service:", error)
 			logger.warn(`[GlobalCLIMcpService] Failed to initialize MCP service:`, error)
 			// Don't throw - allow CLI to continue without MCP
 		}

src/core/task/Task.ts

@@ -50,6 +50,17 @@ import { getWorkspacePath } from "../../utils/path"
 // prompts
 import { formatResponse } from "../prompts/responses"
 import { SYSTEM_PROMPT } from "../prompts/system"
+import { getToolDescriptionsForMode } from "../prompts/tools"
+import {
+	getRulesSection,
+	getSystemInfoSection,
+	getObjectiveSection,
+	getMcpServersSection,
+	getToolUseGuidelinesSection,
+	getCapabilitiesSection,
+	getModesSection,
+	addCustomInstructions,
+} from "../prompts/sections"
 
 // core modules
 import { ToolRepetitionDetector } from "../tools/ToolRepetitionDetector"
@@ -750,6 +761,17 @@ export class Task extends EventEmitter<ClineEvents> {
 				return result
 			}
 
+			case "search_files": {
+				const { searchFilesTool } = await import("../tools/searchFilesTool")
+				const result = await this.executeToolWithCLIInterface(searchFilesTool, {
+					name: toolName,
+					params,
+					type: "tool_use",
+					partial: false,
+				})
+				return result
+			}
+
 			case "attempt_completion": {
 				const { attemptCompletionTool } = await import("../tools/attemptCompletionTool")
 				const result = await this.executeToolWithCLIInterface(attemptCompletionTool, {
@@ -1364,6 +1386,64 @@ ${getObjectiveSection()}`
 			return systemPrompt
 		}
 
+		// In CLI mode, provider might be undefined, so we need to handle this case
+		if (!provider) {
+			// For CLI mode, create a minimal system prompt that includes MCP server information
+			const mcpServersSection = await getMcpServersSection(
+				mcpHub,
+				this.diffEnabled ? this.diffStrategy : undefined,
+				enableMcpServerCreation,
+			)
+
+			const systemPrompt = `You are Roo, a highly skilled software engineer with extensive knowledge in many programming languages, frameworks, design patterns, and best practices. Applying the wisdom in this document (docs/prompts/development-prompt.md), you write the application code
+
+====
+
+MARKDOWN RULES
+
+ALL responses MUST show ANY \`language construct\` OR filename reference as clickable, exactly as [\`filename OR language.declaration()\`](relative/file/path.ext:line); line is required for \`syntax\` and optional for filename links. This applies to ALL markdown responses and ALSO those in <attempt_completion>
+
+====
+
+TOOL USE
+
+You have access to a set of tools that are executed upon the user's approval. You can use one tool per message, and will receive the result of that tool use in the user's response. You use tools step-by-step to accomplish a given task, with each tool use informed by the result of the previous tool use.
+
+${getToolDescriptionsForMode(
+	mode,
+	this.workspacePath,
+	(this.api.getModel().info.supportsComputerUse ?? false) && (browserToolEnabled ?? true),
+	undefined, // codeIndexManager not available in CLI mode
+	this.diffEnabled ? this.diffStrategy : undefined,
+	browserViewportSize,
+	mcpHub,
+	customModes,
+	experiments,
+	maxReadFileLine !== -1,
+	{
+		maxConcurrentFileReads,
+	},
+)}
+
+${getToolUseGuidelinesSection()}
+
+${mcpServersSection}
+
+${getCapabilitiesSection(this.workspacePath, (this.api.getModel().info.supportsComputerUse ?? false) && (browserToolEnabled ?? true), mcpHub, this.diffEnabled ? this.diffStrategy : undefined, undefined)}
+
+${await this.getCliModesSection(customModes)}
+
+${getRulesSection(this.workspacePath, (this.api.getModel().info.supportsComputerUse ?? false) && (browserToolEnabled ?? true), this.diffEnabled ? this.diffStrategy : undefined)}
+
+${getSystemInfoSection(this.workspacePath)}
+
+${getObjectiveSection()}
+
+${await addCustomInstructions("", customInstructions || "", this.workspacePath, mode, { language: language ?? "English", rooIgnoreInstructions })}`
+
+			return systemPrompt
+		}
+
 		return SYSTEM_PROMPT(
 			provider.context,
 			this.workspacePath,
@@ -1387,6 +1467,43 @@ ${getObjectiveSection()}`
 		)
 	}
 
+	/**
+	 * Create a simplified modes section for CLI mode that doesn't require VSCode context
+	 */
+	private async getCliModesSection(customModes?: any[]): Promise<string> {
+		// Import modes directly instead of using VSCode context
+		const { getAllModes } = await import("../../shared/modes")
+		const allModes = getAllModes(customModes)
+
+		let modesContent = `====
+
+MODES
+
+- These are the currently available modes:
+${allModes
+	.map((mode: any) => {
+		let description: string
+		if (mode.whenToUse && mode.whenToUse.trim() !== "") {
+			// Use whenToUse as the primary description, indenting subsequent lines for readability
+			description = mode.whenToUse.replace(/\n/g, "\n    ")
+		} else {
+			// Fallback to the first sentence of roleDefinition if whenToUse is not available
+			description = mode.roleDefinition.split(".")[0]
+		}
+		return `  * "${mode.name}" mode (${mode.slug}) - ${description}`
+	})
+	.join("\n")}`
+
+		modesContent += `
+If the user asks you to create or edit a new mode for this project, you should read the instructions by using the fetch_instructions tool, like this:
+<fetch_instructions>
+<task>create_mode</task>
+</fetch_instructions>
+`
+
+		return modesContent
+	}
+
 	private async getEnvironmentDetails(includeFileDetails: boolean): Promise<string> {
 		return getEnvironmentDetails(this, includeFileDetails)
 	}