mindroot 9.3.0__py3-none-any.whl → 9.6.0__py3-none-any.whl

mindroot/coreplugins/mcp_/catalog_commands.py

@@ -0,0 +1,328 @@
+import os
+import asyncio
+from typing import Dict, List, Optional, Any
+from lib.providers.commands import command
+from .catalog_manager import MCPCatalogManager
+from .mod import mcp_manager, MCPServer
+
+# Global catalog manager
+# Use current working directory for data files
+catalog_manager = MCPCatalogManager(working_dir=os.getcwd())
+
+
+@command()
+async def mcp_catalog_list(category: str = None, context=None):
+    """List MCP servers from catalog
+    
+    Example:
+    { "mcp_catalog_list": {} }
+    { "mcp_catalog_list": { "category": "utilities" } }
+    """
+    # Update running status first
+    catalog = catalog_manager.update_server_status()
+    
+    if category:
+        servers = catalog_manager.get_servers_by_category(category)
+    else:
+        servers = catalog.get("servers", {})
+    
+    # Format for display
+    result = []
+    for name, server in servers.items():
+        result.append({
+            "name": name,
+            "display_name": server.get("display_name", name),
+            "description": server.get("description", ""),
+            "category": server.get("category", "unknown"),
+            "install_method": server.get("install_method", "manual"),
+            "installed": server.get("installed", False),
+            "running": server.get("running", False),
+            "status": server.get("status", "unknown"),
+            "tools": server.get("tools", []),
+            "tags": server.get("tags", [])
+        })
+    
+    return {
+        "servers": result,
+        "count": len(result),
+        "categories": catalog_manager.get_categories()
+    }
+
+
+@command()
+async def mcp_catalog_search(query: str, context=None):
+    """Search MCP servers in catalog
+    
+    Example:
+    { "mcp_catalog_search": { "query": "calculator" } }
+    { "mcp_catalog_search": { "query": "database" } }
+    """
+    servers = catalog_manager.search_servers(query)
+    
+    result = []
+    for name, server in servers.items():
+        result.append({
+            "name": name,
+            "display_name": server.get("display_name", name),
+            "description": server.get("description", ""),
+            "category": server.get("category", "unknown"),
+            "installed": server.get("installed", False),
+            "running": server.get("running", False),
+            "tags": server.get("tags", [])
+        })
+    
+    return {
+        "query": query,
+        "results": result,
+        "count": len(result)
+    }
+
+
+@command()
+async def mcp_catalog_install(server_name: str, context=None):
+    """Install an MCP server from catalog
+    
+    Example:
+    { "mcp_catalog_install": { "server_name": "calculator" } }
+    """
+    server_info = catalog_manager.get_server_info(server_name)
+    if not server_info:
+        return f"Server {server_name} not found in catalog"
+    
+    # Create server config from catalog info
+    server = MCPServer(
+        name=server_info["name"],
+        description=server_info["description"],
+        command=server_info["command"],
+        args=server_info["args"],
+        env=server_info.get("env", {})
+    )
+    
+    # Add to manager
+    mcp_manager.add_server(server_name, server)
+    
+    # Install server if needed (for uvx/npx packages)
+    install_method = server_info.get("install_method", "manual")
+    install_package = server_info.get("install_package")
+    
+    if install_method in ["uvx", "npx"] and install_package:
+        try:
+            import subprocess
+            if install_method == "uvx":
+                result = subprocess.run(["uvx", "--help"], capture_output=True)
+                if result.returncode != 0:
+                    return f"uvx not available. Please install uv first."
+            elif install_method == "npx":
+                result = subprocess.run(["npx", "--version"], capture_output=True)
+                if result.returncode != 0:
+                    return f"npx not available. Please install Node.js first."
+        except Exception as e:
+            return f"Error checking {install_method}: {e}"
+    
+    # Mark as installed (basic implementation)
+    success = True  # For now, assume installation succeeds    
+    if success:
+        catalog_manager.mark_server_installed(server_name, True)
+        return f"Successfully installed {server_name}"
+    else:
+        return f"Failed to install {server_name}"
+
+
+@command()
+async def mcp_catalog_install_and_run(server_name: str, context=None):
+    """Install and run an MCP server from catalog
+    
+    Example:
+    { "mcp_catalog_install_and_run": { "server_name": "calculator" } }
+    """
+    try:
+        # Get server info from catalog
+        server_info = catalog_manager.get_server_info(server_name)
+        if not server_info:
+            return f"Server {server_name} not found in catalog"
+        
+        print(f"Installing and running {server_name}...")
+        
+        # Create server configuration
+        print(f"Creating server configuration for {server_name}...")
+        
+        server_config = MCPServer(
+            name=server_name,
+            description=server_info.get('description', f'MCP Server: {server_name}'),
+            command=server_info['command'],
+            args=server_info.get('args', []),
+            env=server_info.get('env', {}),
+            install_method=server_info.get('install_method', 'manual'),
+            install_package=server_info.get('install_package'),
+            auto_install=True,
+            installed=False
+        )
+        
+        # Add server to manager
+        mcp_manager.add_server(server_name, server_config)
+        
+        # Connect to the server
+        success = await mcp_manager.connect_server(server_name)
+        
+        if success:
+            # Get final server status
+            catalog_manager.update_server_status()
+            
+            # Import and call the refresh function to update dynamic commands
+            try:
+                from .mod import mcp_refresh_dynamic_commands
+                await mcp_refresh_dynamic_commands()
+            except Exception as e:
+                print(f"Warning: Could not refresh dynamic commands: {e}")
+            
+            return f"Successfully installed and connected to {server_name}. MCP tools are now available as commands."
+        else:
+            return f"Installed {server_name} but failed to connect. Check server configuration."
+            
+    except Exception as e:
+        print(f"Error in mcp_catalog_install_and_run: {e}")
+        return f"Error installing and running {server_name}: {str(e)}"
+
+
+@command()
+async def mcp_catalog_stop(server_name: str, context=None):
+    """Stop an MCP server
+    
+    Example:
+    { "mcp_catalog_stop": { "server_name": "calculator" } }
+    """
+    success = await mcp_manager.disconnect_server(server_name)
+    
+    if success:
+        catalog_manager.update_server_status()
+        return f"Successfully stopped {server_name}"
+    else:
+        return f"Failed to stop {server_name}"
+
+
+@command()
+async def mcp_catalog_status(context=None):
+    """Get status of all catalog servers
+    
+    Example:
+    { "mcp_catalog_status": {} }
+    """
+    catalog = catalog_manager.update_server_status()
+    servers = catalog.get("servers", {})
+    
+    status_summary = {
+        "total": len(servers),
+        "installed": 0,
+        "running": 0,
+        "available": 0
+    }
+    
+    server_status = []
+    
+    for name, server in servers.items():
+        installed = server.get("installed", False)
+        running = server.get("running", False)
+        
+        if installed:
+            status_summary["installed"] += 1
+        if running:
+            status_summary["running"] += 1
+        if server.get("status") == "available":
+            status_summary["available"] += 1
+        
+        server_status.append({
+            "name": name,
+            "display_name": server.get("display_name", name),
+            "installed": installed,
+            "running": running,
+            "category": server.get("category", "unknown")
+        })
+    
+    return {
+        "summary": status_summary,
+        "servers": server_status
+    }
+
+
+@command()
+async def mcp_catalog_info(server_name: str, context=None):
+    """Get detailed info about a catalog server
+    
+    Example:
+    { "mcp_catalog_info": { "server_name": "calculator" } }
+    """
+    server_info = catalog_manager.get_server_info(server_name)
+    
+    if not server_info:
+        return f"Server {server_name} not found in catalog"
+    
+    # Update running status
+    running_status = catalog_manager.detect_running_servers()
+    server_info["running"] = running_status.get(server_name, False)
+    
+    return server_info
+
+
+@command()
+async def mcp_catalog_categories(context=None):
+    """Get list of server categories
+    
+    Example:
+    { "mcp_catalog_categories": {} }
+    """
+    categories = catalog_manager.get_categories()
+    catalog = catalog_manager.load_catalog()
+    
+    # Count servers per category
+    category_counts = {}
+    for server in catalog.get("servers", {}).values():
+        category = server.get("category", "unknown")
+        category_counts[category] = category_counts.get(category, 0) + 1
+    
+    return {
+        "categories": categories,
+        "counts": category_counts
+    }
+
+
+@command()
+async def mcp_catalog_add_custom(server_info: Dict[str, Any], context=None):
+    """Add a custom server to the catalog
+    
+    Example:
+    { "mcp_catalog_add_custom": {
+        "server_info": {
+            "name": "my_server",
+            "display_name": "My Custom Server",
+            "description": "Custom MCP server",
+            "command": "python",
+            "args": ["-m", "my_mcp_server"],
+            "category": "custom",
+            "install_method": "manual"
+        }
+    }}
+    """
+    success = catalog_manager.add_custom_server(server_info)
+    
+    if success:
+        return f"Successfully added custom server {server_info.get('name')}"
+    else:
+        return "Failed to add custom server - missing required fields"
+
+
+@command()
+async def mcp_catalog_refresh(context=None):
+    """Refresh catalog and update server status
+    
+    Example:
+    { "mcp_catalog_refresh": {} }
+    """
+    catalog = catalog_manager.update_server_status()
+    running_count = sum(1 for server in catalog.get("servers", {}).values() 
+                       if server.get("running", False))
+    
+    return {
+        "message": "Catalog refreshed",
+        "total_servers": len(catalog.get("servers", {})),
+        "running_servers": running_count
+    }

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))