natureco-cli 2.10.0 → 2.10.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "natureco-cli",
-  "version": "2.10.0",
+  "version": "2.10.1",
   "description": "NatureCo AI Bot Terminal Interface",
   "main": "bin/natureco.js",
   "bin": {

package/src/commands/dashboard.js

@@ -211,7 +211,7 @@ body::before{
         <div class="header-bot-name" id="header-bot-name">Nature Bot</div>
         <div class="header-bot-model" id="header-bot-model">NatureCo</div>
       </div>
-      <div class="version-badge" id="version-badge">v2.10.0</div>
+      <div class="version-badge" id="version-badge">v2.10.1</div>
     </div>
     <div class="messages" id="messages"></div>
     <div class="input-area">
@@ -341,7 +341,7 @@ function dashboard(action) {
           apiKey: cfg.apiKey,
           defaultBot: cfg.defaultBot,
           defaultBotId: cfg.defaultBotId,
-          version: 'v2.10.0',
+          version: 'v2.10.1',
           bots: cfg.bots || [],
           telegramToken: cfg.telegramToken || null,
           whatsappConnected: cfg.whatsappConnected || false,

package/src/commands/gateway-server.js

@@ -138,7 +138,7 @@ async function startGateway() {
 
 async function runGatewayWorker() {
   // This runs in the background
-  log('gateway', 'Starting NatureCo Gateway v2.9.2...', 'green');
+  log('gateway', 'Starting NatureCo Gateway v2.10.1...', 'green');
   
   // Load config
   const { getConfig } = require('../utils/config');

package/src/utils/api.js

@@ -1,4 +1,4 @@
-// NatureCo CLI v2.8.0 - Universal LLM Provider Support
+// NatureCo CLI v2.10.1 - Universal LLM Provider Support + MCP Integration
 // Supports: OpenAI, Groq, Together, Fireworks, Perplexity, Mistral, DeepSeek, OpenRouter, Ollama, LM Studio, Anthropic
 
 const fs = require('fs');
@@ -6,6 +6,7 @@ const os = require('os');
 const path = require('path');
 const { getConfig } = require('./config');
 const { getToolDefinitions, executeToolCalls } = require('./tool-runner');
+const { MCPClient } = require('./mcp-client');
 
 // Persistent conversation directory
 const CONV_DIR = path.join(os.homedir(), '.natureco', 'conversations');
@@ -13,6 +14,9 @@ const CONV_DIR = path.join(os.homedir(), '.natureco', 'conversations');
 // Conversation history for multi-turn chat (deprecated - now using disk storage)
 const conversationHistory = new Map();
 
+// MCP clients (server name -> { client, tools })
+const mcpClients = {};
+
 /**
  * Generate default conversation ID based on provider config
  */
@@ -60,6 +64,124 @@ function saveConversation(convId, messages) {
   }
 }
 
+/**
+ * Start MCP servers from config
+ */
+async function startMcpServers() {
+  const config = getConfig();
+  const servers = config.mcpServers || {};
+  
+  for (const [name, server] of Object.entries(servers)) {
+    // Skip disabled servers
+    if (server.disabled) {
+      debugLog(`[MCP] Skipping disabled server: ${name}`);
+      continue;
+    }
+    
+    // Skip if already started
+    if (mcpClients[name]) {
+      debugLog(`[MCP] Server already running: ${name}`);
+      continue;
+    }
+    
+    try {
+      debugLog(`[MCP] Starting server: ${name}`);
+      
+      const client = new MCPClient(server.command, server.args, server.env || {});
+      await client.start();
+      
+      const tools = await client.listTools();
+      debugLog(`[MCP] Server ${name} loaded ${tools.length} tools`);
+      
+      mcpClients[name] = { client, tools };
+      
+    } catch (err) {
+      debugLog(`[MCP] Failed to start server ${name}: ${err.message}`);
+    }
+  }
+}
+
+/**
+ * Stop all MCP servers
+ */
+function stopMcpServers() {
+  for (const [name, { client }] of Object.entries(mcpClients)) {
+    try {
+      debugLog(`[MCP] Stopping server: ${name}`);
+      client.stop();
+    } catch (err) {
+      debugLog(`[MCP] Failed to stop server ${name}: ${err.message}`);
+    }
+  }
+  
+  // Clear clients
+  Object.keys(mcpClients).forEach(key => delete mcpClients[key]);
+}
+
+/**
+ * Get all MCP tools (combined from all servers)
+ */
+function getMcpTools() {
+  const allTools = [];
+  
+  for (const [serverName, { tools }] of Object.entries(mcpClients)) {
+    for (const tool of tools) {
+      allTools.push({
+        ...tool,
+        _mcpServer: serverName, // Track which server this tool belongs to
+      });
+    }
+  }
+  
+  return allTools;
+}
+
+/**
+ * Execute MCP tool call
+ */
+async function executeMcpTool(toolName, toolArgs) {
+  // Find which server has this tool
+  for (const [serverName, { client, tools }] of Object.entries(mcpClients)) {
+    const tool = tools.find(t => t.name === toolName);
+    
+    if (tool) {
+      debugLog(`[MCP] Calling tool ${toolName} on server ${serverName}`);
+      
+      try {
+        const result = await client.callTool(toolName, toolArgs);
+        
+        // MCP returns { content: [{ type: 'text', text: '...' }] }
+        if (result.content && result.content.length > 0) {
+          const textContent = result.content.find(c => c.type === 'text');
+          if (textContent) {
+            return {
+              success: true,
+              output: textContent.text
+            };
+          }
+        }
+        
+        // Fallback: return entire result
+        return {
+          success: true,
+          output: JSON.stringify(result, null, 2)
+        };
+        
+      } catch (err) {
+        return {
+          success: false,
+          error: `MCP tool error: ${err.message}`
+        };
+      }
+    }
+  }
+  
+  return {
+    success: false,
+    error: `MCP tool not found: ${toolName}`
+  };
+}
+
 /**
  * Check if debug mode is enabled
  */
@@ -110,14 +232,18 @@ function getProviderConfig() {
  * Format tool definitions for OpenAI-compatible APIs
  */
 function formatToolsForOpenAI() {
-  const tools = getToolDefinitions();
+  const localTools = getToolDefinitions();
+  const mcpTools = getMcpTools();
+  
+  // Combine local and MCP tools
+  const allTools = [...localTools, ...mcpTools];
   
-  return tools.map(tool => ({
+  return allTools.map(tool => ({
     type: 'function',
     function: {
       name: tool.name,
       description: tool.description,
-      parameters: tool.inputSchema
+      parameters: tool.inputSchema || tool.input_schema || { type: 'object', properties: {} }
     }
   }));
 }
@@ -126,12 +252,16 @@ function formatToolsForOpenAI() {
  * Format tool definitions for Anthropic API
  */
 function formatToolsForAnthropic() {
-  const tools = getToolDefinitions();
+  const localTools = getToolDefinitions();
+  const mcpTools = getMcpTools();
   
-  return tools.map(tool => ({
+  // Combine local and MCP tools
+  const allTools = [...localTools, ...mcpTools];
+  
+  return allTools.map(tool => ({
     name: tool.name,
     description: tool.description,
-    input_schema: tool.inputSchema
+    input_schema: tool.inputSchema || tool.input_schema || { type: 'object', properties: {} }
   }));
 }
 
@@ -234,6 +364,11 @@ async function sendMessageToProvider(apiKey, message, conversationId = null, sys
     );
   }
 
+  // Start MCP servers if not already started
+  if (Object.keys(mcpClients).length === 0) {
+    await startMcpServers();
+  }
+
   // Get or create conversation history (load from disk)
   // Use consistent ID based on provider config instead of timestamp
   const convId = conversationId || generateDefaultConvId();
@@ -247,7 +382,7 @@ async function sendMessageToProvider(apiKey, message, conversationId = null, sys
   messages.push(...history);
   messages.push({ role: 'user', content: message });
 
-  // Get tool definitions
+  // Get tool definitions (local + MCP)
   const tools = providerConfig.isAnthropic 
     ? formatToolsForAnthropic() 
     : formatToolsForOpenAI();
@@ -257,7 +392,7 @@ async function sendMessageToProvider(apiKey, message, conversationId = null, sys
   debugLog('[Provider] Model:', providerConfig.model);
   debugLog('[Provider] Type:', providerConfig.isAnthropic ? 'Anthropic' : 'OpenAI-compatible');
   debugLog('[Provider] Messages:', messages.length);
-  debugLog('[Provider] Tools:', tools.length);
+  debugLog('[Provider] Tools:', tools.length, `(${Object.keys(mcpClients).length} MCP servers)`);
 
   // Tool execution loop (max 10 iterations)
   let iteration = 0;
@@ -282,14 +417,36 @@ async function sendMessageToProvider(apiKey, message, conversationId = null, sys
     if (assistantMessage.tool_calls && assistantMessage.tool_calls.length > 0) {
       debugLog(`[Provider] Tool calls: ${assistantMessage.tool_calls.length}`);
 
-      // Execute tools locally
+      // Separate local and MCP tool calls
       const toolCalls = assistantMessage.tool_calls.map(tc => ({
         id: tc.id,
         name: tc.function.name,
         input: JSON.parse(tc.function.arguments)
       }));
 
-      const toolResults = await executeToolCalls(toolCalls);
+      const toolResults = [];
+
+      for (const toolCall of toolCalls) {
+        // Check if this is an MCP tool
+        const mcpTools = getMcpTools();
+        const isMcpTool = mcpTools.find(t => t.name === toolCall.name);
+
+        if (isMcpTool) {
+          // Execute MCP tool
+          debugLog(`[MCP] Executing tool: ${toolCall.name}`);
+          const result = await executeMcpTool(toolCall.name, toolCall.input);
+          toolResults.push({
+            id: toolCall.id,
+            name: toolCall.name,
+            result: result
+          });
+        } else {
+          // Execute local tool
+          debugLog(`[Local] Executing tool: ${toolCall.name}`);
+          const localResults = await executeToolCalls([toolCall]);
+          toolResults.push(...localResults);
+        }
+      }
 
       // Add tool results to messages (base64 encoded for safety)
       for (const result of toolResults) {
@@ -452,5 +609,8 @@ module.exports = {
   getBots,
   clearConversation,
   getProviderConfig,
+  startMcpServers,
+  stopMcpServers,
+  getMcpTools,
   _sendMessage: sendMessage, // Alias for compatibility
 };

package/src/utils/mcp.js

@@ -83,6 +83,7 @@ function addMcpServer(name, template = null, customConfig = null) {
   servers[name] = {
     ...serverConfig,
     disabled: false,
+    enabled: true,
     autoApprove: [],
   };