natureco-cli 2.9.2 → 2.10.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "natureco-cli",
-  "version": "2.9.2",
+  "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.9.2</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.9.2',
+          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-client.js

@@ -0,0 +1,311 @@
+const { spawn } = require('child_process');
+const { EventEmitter } = require('events');
+
+/**
+ * MCP Client - JSON-RPC over stdio
+ * Manages communication with MCP servers via stdin/stdout
+ */
+class MCPClient extends EventEmitter {
+  constructor(command, args = [], env = {}) {
+    super();
+    this.command = command;
+    this.args = args;
+    this.env = { ...process.env, ...env };
+    this.process = null;
+    this.messageId = 0;
+    this.pendingRequests = new Map();
+    this.buffer = '';
+    this.isInitialized = false;
+  }
+
+  /**
+   * Start MCP server process
+   */
+  async start() {
+    return new Promise((resolve, reject) => {
+      try {
+        this.process = spawn(this.command, this.args, {
+          env: this.env,
+          stdio: ['pipe', 'pipe', 'pipe'],
+        });
+
+        // Handle stdout (JSON-RPC responses)
+        this.process.stdout.on('data', (data) => {
+          this.handleData(data);
+        });
+
+        // Handle stderr (logs)
+        this.process.stderr.on('data', (data) => {
+          const message = data.toString().trim();
+          if (message) {
+            this.emit('log', message);
+          }
+        });
+
+        // Handle process exit
+        this.process.on('exit', (code) => {
+          this.emit('exit', code);
+          this.cleanup();
+        });
+
+        // Handle process error
+        this.process.on('error', (err) => {
+          reject(err);
+        });
+
+        // Initialize connection
+        this.initialize()
+          .then(() => {
+            this.isInitialized = true;
+            resolve();
+          })
+          .catch(reject);
+
+      } catch (err) {
+        reject(err);
+      }
+    });
+  }
+
+  /**
+   * Handle incoming data from stdout
+   */
+  handleData(data) {
+    this.buffer += data.toString();
+
+    // Process complete JSON-RPC messages (newline-delimited)
+    const lines = this.buffer.split('\n');
+    this.buffer = lines.pop() || ''; // Keep incomplete line in buffer
+
+    for (const line of lines) {
+      if (!line.trim()) continue;
+
+      try {
+        const message = JSON.parse(line);
+        this.handleMessage(message);
+      } catch (err) {
+        this.emit('error', new Error(`Failed to parse JSON-RPC message: ${err.message}`));
+      }
+    }
+  }
+
+  /**
+   * Handle parsed JSON-RPC message
+   */
+  handleMessage(message) {
+    // Response to our request
+    if (message.id !== undefined && this.pendingRequests.has(message.id)) {
+      const { resolve, reject } = this.pendingRequests.get(message.id);
+      this.pendingRequests.delete(message.id);
+
+      if (message.error) {
+        reject(new Error(message.error.message || 'MCP request failed'));
+      } else {
+        resolve(message.result);
+      }
+    }
+    // Notification from server
+    else if (message.method) {
+      this.emit('notification', message);
+    }
+  }
+
+  /**
+   * Send JSON-RPC request
+   */
+  async sendRequest(method, params = {}) {
+    if (!this.process || this.process.killed) {
+      throw new Error('MCP server not running');
+    }
+
+    const id = ++this.messageId;
+    const request = {
+      jsonrpc: '2.0',
+      id,
+      method,
+      params,
+    };
+
+    return new Promise((resolve, reject) => {
+      this.pendingRequests.set(id, { resolve, reject });
+
+      // Timeout after 30 seconds
+      const timeout = setTimeout(() => {
+        if (this.pendingRequests.has(id)) {
+          this.pendingRequests.delete(id);
+          reject(new Error(`Request timeout: ${method}`));
+        }
+      }, 30000);
+
+      // Clear timeout on response
+      const originalResolve = resolve;
+      const originalReject = reject;
+      
+      this.pendingRequests.set(id, {
+        resolve: (result) => {
+          clearTimeout(timeout);
+          originalResolve(result);
+        },
+        reject: (err) => {
+          clearTimeout(timeout);
+          originalReject(err);
+        },
+      });
+
+      // Send request
+      const message = JSON.stringify(request) + '\n';
+      this.process.stdin.write(message);
+    });
+  }
+
+  /**
+   * Initialize MCP connection
+   */
+  async initialize() {
+    const result = await this.sendRequest('initialize', {
+      protocolVersion: '2024-11-05',
+      capabilities: {
+        roots: {
+          listChanged: false
+        }
+      },
+      clientInfo: {
+        name: 'natureco-cli',
+        version: '2.10.0',
+      },
+    });
+
+    // Send initialized notification
+    const notification = {
+      jsonrpc: '2.0',
+      method: 'notifications/initialized',
+    };
+    this.process.stdin.write(JSON.stringify(notification) + '\n');
+
+    return result;
+  }
+
+  /**
+   * List available tools
+   */
+  async listTools() {
+    if (!this.isInitialized) {
+      throw new Error('MCP client not initialized');
+    }
+
+    const result = await this.sendRequest('tools/list', {});
+    return result.tools || [];
+  }
+
+  /**
+   * Call a tool
+   */
+  async callTool(toolName, args = {}) {
+    if (!this.isInitialized) {
+      throw new Error('MCP client not initialized');
+    }
+
+    const result = await this.sendRequest('tools/call', {
+      name: toolName,
+      arguments: args,
+    });
+
+    return result;
+  }
+
+  /**
+   * Stop MCP server
+   */
+  stop() {
+    if (this.process && !this.process.killed) {
+      this.process.kill();
+    }
+    this.cleanup();
+  }
+
+  /**
+   * Cleanup resources
+   */
+  cleanup() {
+    this.pendingRequests.clear();
+    this.buffer = '';
+    this.isInitialized = false;
+    this.process = null;
+  }
+}
+
+/**
+ * Create and start MCP client
+ */
+async function createMCPClient(command, args = [], env = {}) {
+  const client = new MCPClient(command, args, env);
+  await client.start();
+  return client;
+}
+
+/**
+ * Test function - Start filesystem MCP server and list tools
+ */
+async function test() {
+  console.log('🧪 Testing MCP Client...\n');
+
+  try {
+    // Start filesystem MCP server
+    console.log('Starting filesystem MCP server...');
+    const client = await createMCPClient('npx', [
+      '-y',
+      '@modelcontextprotocol/server-filesystem',
+      process.cwd(),
+    ]);
+
+    console.log('✅ MCP server started\n');
+
+    // Listen to logs
+    client.on('log', (message) => {
+      console.log('[MCP Log]', message);
+    });
+
+    // List tools
+    console.log('Listing tools...');
+    const tools = await client.listTools();
+    console.log(`✅ Found ${tools.length} tools:\n`);
+
+    tools.forEach((tool) => {
+      console.log(`  - ${tool.name}`);
+      console.log(`    ${tool.description}`);
+      console.log('');
+    });
+
+    // Test tool call - read directory
+    if (tools.find(t => t.name === 'read_file')) {
+      console.log('Testing read_file tool...');
+      try {
+        const result = await client.callTool('read_file', {
+          path: 'package.json',
+        });
+        console.log('✅ Tool call successful');
+        console.log('Result:', JSON.stringify(result, null, 2).substring(0, 200) + '...\n');
+      } catch (err) {
+        console.log('❌ Tool call failed:', err.message, '\n');
+      }
+    }
+
+    // Stop server
+    console.log('Stopping MCP server...');
+    client.stop();
+    console.log('✅ Test completed\n');
+
+    process.exit(0);
+
+  } catch (err) {
+    console.error('❌ Test failed:', err.message);
+    console.error(err.stack);
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  MCPClient,
+  createMCPClient,
+  test,
+};

package/src/utils/mcp.js

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