mindroot 9.2.0__py3-none-any.whl → 9.5.0__py3-none-any.whl

mindroot/coreplugins/mcp_/catalog_manager.py

@@ -0,0 +1,263 @@
+import json
+import os
+import psutil
+import subprocess
+from pathlib import Path
+from typing import Dict, List, Optional, Any
+
+class MCPCatalogManager:
+    """Manages MCP server catalog and process detection"""
+    
+    def __init__(self, plugin_dir: str = None, working_dir: str = None):
+        # Default plugin_dir to the directory containing this module
+        if plugin_dir is None:
+            plugin_dir = Path(__file__).parent.parent.parent
+        self.plugin_dir = Path(plugin_dir)
+        
+        # Use process working directory for data files
+        if working_dir is None:
+            working_dir = os.getcwd()
+        self.working_dir = Path(working_dir)
+        
+        self.catalog_file = self.working_dir / "data" / "mcp" / "servers.json"
+        self.default_file = Path(__file__).parent / "data" / "default_mcp_servers.json"
+        self.ensure_catalog_exists()
+        
+    
+    def ensure_catalog_exists(self):
+        """Ensure catalog file exists, create from default if needed"""
+        if not self.catalog_file.exists():
+            if self.default_file.exists():
+                self.init_catalog_from_default()
+            else:
+                self.create_empty_catalog()
+    
+    def init_catalog_from_default(self):
+        """Initialize catalog from default servers"""
+        # Ensure the target directory exists
+        self.catalog_file.parent.mkdir(parents=True, exist_ok=True)
+        
+        try:
+            with open(self.default_file, 'r') as f:
+                default_servers = json.load(f)
+            
+            catalog = {
+                "_metadata": {
+                    "version": "1.0.0",
+                    "last_updated": "2025-06-02",
+                    "description": "MCP Server Catalog for MindRoot",
+                    "categories": ["utilities", "system", "development", "search", "database", "communication", "cloud", "automation", "ai"]
+                },
+                "servers": {}
+            }
+            
+            for name, server in default_servers.items():
+                server["status"] = "available"
+                server["installed"] = False
+                server["running"] = False
+                catalog["servers"][name] = server
+            
+            with open(self.catalog_file, 'w') as f:
+                json.dump(catalog, f, indent=2)
+                
+        except Exception as e:
+            print(f"Error initializing catalog: {e}")
+            self.create_empty_catalog()
+    
+    def create_empty_catalog(self):
+        """Create empty catalog structure"""
+        catalog = {
+            "_metadata": {
+                "version": "1.0.0",
+                "last_updated": "2025-06-02",
+                "description": "MCP Server Catalog for MindRoot",
+                "categories": []
+            },
+            "servers": {}
+        }
+        
+        self.catalog_file.parent.mkdir(parents=True, exist_ok=True)
+        with open(self.catalog_file, 'w') as f:
+            json.dump(catalog, f, indent=2)
+    
+    def load_catalog(self) -> Dict[str, Any]:
+        """Load the server catalog"""
+        try:
+            with open(self.catalog_file, 'r') as f:
+                return json.load(f)
+        except Exception as e:
+            print(f"Error loading catalog: {e}")
+            return {"_metadata": {}, "servers": {}}
+    
+    def save_catalog(self, catalog: Dict[str, Any]):
+        """Save the server catalog"""
+        try:
+            with open(self.catalog_file, 'w') as f:
+                json.dump(catalog, f, indent=2)
+        except Exception as e:
+            print(f"Error saving catalog: {e}")
+    
+    def get_running_processes(self) -> List[Dict[str, Any]]:
+        """Get list of running processes with details"""
+        processes = []
+        try:
+            for proc in psutil.process_iter(['pid', 'name', 'cmdline']):
+                try:
+                    processes.append({
+                        'pid': proc.info['pid'],
+                        'name': proc.info['name'],
+                        'cmdline': proc.info['cmdline'] or []
+                    })
+                except (psutil.NoSuchProcess, psutil.AccessDenied):
+                    continue
+        except Exception as e:
+            print(f"Error getting processes: {e}")
+        
+        return processes
+    
+    def detect_running_servers(self) -> Dict[str, bool]:
+        """Detect which MCP servers are currently running"""
+        catalog = self.load_catalog()
+        running_status = {}
+        processes = self.get_running_processes()
+        
+        for server_name, server_info in catalog.get("servers", {}).items():
+            is_running = False
+            process_names = server_info.get("process_names", [])
+            
+            for proc in processes:
+                # Check process name
+                if proc['name'] in process_names:
+                    is_running = True
+                    break
+                
+                # Check command line for MCP server patterns
+                cmdline_str = ' '.join(proc['cmdline'])
+                for process_name in process_names:
+                    if process_name in cmdline_str:
+                        is_running = True
+                        break
+                
+                # Check for specific patterns
+                if server_name in cmdline_str or server_info.get('install_package', '') in cmdline_str:
+                    is_running = True
+                    break
+                
+                if is_running:
+                    break
+            
+            running_status[server_name] = is_running
+        
+        return running_status
+    
+    def update_server_status(self):
+        """Update running status for all servers in catalog"""
+        catalog = self.load_catalog()
+        running_status = self.detect_running_servers()
+        
+        for server_name, is_running in running_status.items():
+            if server_name in catalog.get("servers", {}):
+                catalog["servers"][server_name]["running"] = is_running
+        
+        self.save_catalog(catalog)
+        return catalog
+    
+    def get_servers_by_category(self, category: str = None) -> Dict[str, Any]:
+        """Get servers filtered by category"""
+        catalog = self.load_catalog()
+        servers = catalog.get("servers", {})
+        
+        if category is None:
+            return servers
+        
+        filtered = {}
+        for name, server in servers.items():
+            if server.get("category") == category:
+                filtered[name] = server
+        
+        return filtered
+    
+    def get_server_info(self, server_name: str) -> Optional[Dict[str, Any]]:
+        """Get detailed info for a specific server"""
+        catalog = self.load_catalog()
+        return catalog.get("servers", {}).get(server_name)
+    
+    def mark_server_installed(self, server_name: str, installed: bool = True):
+        """Mark a server as installed or not"""
+        catalog = self.load_catalog()
+        if server_name in catalog.get("servers", {}):
+            catalog["servers"][server_name]["installed"] = installed
+            self.save_catalog(catalog)
+    
+    def add_custom_server(self, server_info: Dict[str, Any]):
+        """Add a custom server to the catalog"""
+        catalog = self.load_catalog()
+        server_name = server_info.get("name")
+        
+        if server_name:
+            # Add default fields if missing
+            server_info.setdefault("status", "custom")
+            server_info.setdefault("installed", False)
+            server_info.setdefault("running", False)
+            server_info.setdefault("category", "custom")
+            server_info.setdefault("tags", [])
+            
+            catalog["servers"][server_name] = server_info
+            self.save_catalog(catalog)
+            return True
+        
+        return False
+    
+    def remove_server(self, server_name: str):
+        """Remove a server from the catalog"""
+        catalog = self.load_catalog()
+        if server_name in catalog.get("servers", {}):
+            del catalog["servers"][server_name]
+            self.save_catalog(catalog)
+            return True
+        return False
+    
+    def search_servers(self, query: str) -> Dict[str, Any]:
+        """Search servers by name, description, or tags"""
+        catalog = self.load_catalog()
+        servers = catalog.get("servers", {})
+        results = {}
+        
+        query_lower = query.lower()
+        
+        for name, server in servers.items():
+            # Search in name
+            if query_lower in name.lower():
+                results[name] = server
+                continue
+            
+            # Search in display name
+            if query_lower in server.get("display_name", "").lower():
+                results[name] = server
+                continue
+            
+            # Search in description
+            if query_lower in server.get("description", "").lower():
+                results[name] = server
+                continue
+            
+            # Search in tags
+            tags = server.get("tags", [])
+            if any(query_lower in tag.lower() for tag in tags):
+                results[name] = server
+                continue
+        
+        return results
+    
+    def get_categories(self) -> List[str]:
+        """Get list of all categories"""
+        catalog = self.load_catalog()
+        categories = set(catalog.get("_metadata", {}).get("categories", []))
+        
+        # Add categories from servers
+        for server in catalog.get("servers", {}).values():
+            category = server.get("category")
+            if category:
+                categories.add(category)
+        
+        return sorted(list(categories))

mindroot/coreplugins/mcp_/dynamic_commands.py

@@ -0,0 +1,154 @@
+from typing import Dict, List, Any
+import json
+import inspect
+from lib.providers.commands import command_manager
+
+class MCPDynamicCommands:
+    """Handles dynamic registration of MCP tools as MindRoot commands"""
+    
+    def __init__(self):
+        self.registered_commands: Dict[str, str] = {}  # cmd_name -> server_name
+        self.sessions: Dict[str, Any] = {}  # Reference to sessions
+    
+    def set_sessions(self, sessions: Dict[str, Any]):
+        """Set reference to MCP sessions"""
+        self.sessions = sessions
+    
+    async def register_tools(self, server_name: str, tools: List[Any]):
+        """Register MCP tools as dynamic MindRoot commands"""
+        for tool in tools:
+            try:
+                tool_name = tool.name
+                #cmd_name = f"mcp_{server_name}_{tool_name}"
+                cmd_name = "mcp_"+tool_name
+ 
+                self.registered_commands[cmd_name] = server_name
+                
+                # Create wrapper function with closure to capture current values
+                def create_wrapper(srv_name, tl_name):
+                    async def mcp_tool_wrapper(*args, context=None, **kwargs):
+                        if srv_name not in self.sessions:
+                            return f"MCP server {srv_name} not connected"
+                        
+                        session = self.sessions[srv_name]
+                        
+                        # Convert arguments to MCP format
+                        if len(args) == 1 and isinstance(args[0], dict):
+                            arguments = args[0]
+                        elif kwargs:
+                            # Filter out context from kwargs
+                            arguments = {k: v for k, v in kwargs.items() if k != 'context'}
+                        else:
+                            arguments = {}
+                        
+                        try:
+                            result = await session.call_tool(tl_name, arguments)
+                            
+                            # Extract content from CallToolResult object
+                            if hasattr(result, 'content'):
+                                if isinstance(result.content, list) and len(result.content) > 0:
+                                    # Return the text content of the first item
+                                    first_item = result.content[0]
+                                    return first_item.text if hasattr(first_item, 'text') else str(first_item)
+                                else:
+                                    return str(result.content)
+                            else:
+                                return str(result)
+                        except Exception as e:
+                            return f"Error calling MCP tool {tl_name}: {str(e)}"
+                    
+                    return mcp_tool_wrapper
+                
+                wrapper = create_wrapper(server_name, tool_name)
+                
+                # Create docstring with parameter information
+                description = getattr(tool, 'description', 'No description available')
+                
+                # Extract parameter schema if available
+                param_info = ""
+                example_args = {}
+                
+                if hasattr(tool, 'inputSchema') and tool.inputSchema:
+                    schema = tool.inputSchema
+                    if isinstance(schema, dict) and 'properties' in schema:
+                        properties = schema['properties']
+                        required = schema.get('required', [])
+                        
+                        param_lines = []
+                        for param_name, param_def in properties.items():
+                            param_type = param_def.get('type', 'any')
+                            param_desc = param_def.get('description', '')
+                            is_required = param_name in required
+                            req_text = ' (required)' if is_required else ' (optional)'
+                            param_lines.append(f"  {param_name} ({param_type}){req_text}: {param_desc}")
+                            
+                            # Create example value based on type
+                            if param_type == 'string':
+                                example_args[param_name] = f"example_{param_name}"
+                            elif param_type == 'number':
+                                example_args[param_name] = 42
+                            elif param_type == 'boolean':
+                                example_args[param_name] = True
+                            else:
+                                example_args[param_name] = f"value_for_{param_name}"
+                        
+                        if param_lines:
+                            param_info = "\n\nParameters:\n" + "\n".join(param_lines)
+                
+                # Use actual parameter names in example if available
+                example_json = json.dumps(example_args, indent=2) if example_args else '{"arg1": "value1"}'
+                
+                docstring = f"""MCP Tool: {tool_name} from {server_name}
+
+{description}{param_info}
+
+{description}
+
+Example:
+{{ "{cmd_name}": {example_json} }}
+"""
+                
+                # Register with command manager
+                try:
+                    command_manager.register_function(
+                        name=cmd_name,
+                        provider="mcp",
+                        implementation=wrapper,
+                        signature=inspect.signature(wrapper),
+                        docstring=docstring,
+                        flags=[]
+                    )
+                    print(f"Registered MCP command: {cmd_name}")
+                    
+                    # Verify registration
+                    if cmd_name in command_manager.functions:
+                        print(f"  ✅ Verified: {cmd_name} is in command manager")
+                    else:
+                        print(f"  ❌ Warning: {cmd_name} not found in command manager after registration")
+                except Exception as e:
+                    print(f"Error registering {cmd_name}: {e}")
+                    
+            except Exception as e:
+                print(f"Error processing tool {getattr(tool, 'name', 'unknown')}: {e}")
+                continue
+    
+    async def unregister_server_tools(self, server_name: str):
+        """Unregister all tools for a server"""
+        commands_to_remove = []
+        for cmd_name, srv_name in self.registered_commands.items():
+            if srv_name == server_name:
+                commands_to_remove.append(cmd_name)
+        
+        for cmd_name in commands_to_remove:
+            try:
+                if cmd_name in command_manager.functions:
+                    del command_manager.functions[cmd_name]
+                del self.registered_commands[cmd_name]
+                print(f"Unregistered MCP command: {cmd_name}")
+            except Exception as e:
+                print(f"Error unregistering {cmd_name}: {e}")
+    
+    def get_registered_commands(self) -> List[str]:
+        """Get list of registered command names"""
+        return list(self.registered_commands.keys())
+