Upload app.py with huggingface_hub

app.py

@@ -5016,6 +5016,378 @@ class ProactiveIntelligence:
         return None
 
 
+# ============================================================================
+# MCP CLIENT — Model Context Protocol for unlimited external tools
+# ============================================================================
+
+class MCPClient:
+    """Model Context Protocol client — connect to ANY MCP server.
+    
+    MCP is Anthropic's open standard for AI-tool communication.
+    This lets Hermes connect to 200+ external tools (GitHub, Slack,
+    databases, browsers, file systems, etc.) without custom code.
+    
+    How it works:
+    1. User says "connect to github mcp"
+    2. MCPClient spawns the MCP server (e.g., npx @anthropic/github-mcp)
+    3. Does JSON-RPC handshake over stdio
+    4. Discovers available tools
+    5. Registers them in TOOL_REGISTRY
+    6. Hermes can now call those tools via [[TOOL:mcp_toolname|args]]
+    
+    Popular MCP servers:
+    - @anthropic/github-mcp — GitHub repos, PRs, issues
+    - @anthropic/filesystem-mcp — Read/write files
+    - @anthropic/postgres-mcp — PostgreSQL queries
+    - @anthropic/brave-search-mcp — Web search
+    - @anthropic/memory-mcp — Persistent key-value memory
+    - @anthropic/puppeteer-mcp — Browser automation
+    - @anthropic/slack-mcp — Slack messages
+    - @anthropic/sqlite-mcp — SQLite databases
+    """
+    
+    _servers: Dict[str, Dict] = {}  # name → {process, tools, config}
+    _loaded = False
+    
+    # Popular MCP servers for easy connection
+    POPULAR_SERVERS = {
+        "github": {
+            "command": "npx",
+            "args": ["-y", "@anthropic/github-mcp"],
+            "env": ["GITHUB_TOKEN"],
+            "description": "GitHub: manage repos, PRs, issues, code review",
+        },
+        "filesystem": {
+            "command": "npx",
+            "args": ["-y", "@anthropic/filesystem-mcp", "/app"],
+            "env": [],
+            "description": "Filesystem: read/write files on the server",
+        },
+        "memory": {
+            "command": "npx",
+            "args": ["-y", "@anthropic/memory-mcp"],
+            "env": [],
+            "description": "Persistent key-value memory storage",
+        },
+        "brave-search": {
+            "command": "npx",
+            "args": ["-y", "@anthropic/brave-search-mcp"],
+            "env": ["BRAVE_API_KEY"],
+            "description": "Advanced web search with filters",
+        },
+        "puppeteer": {
+            "command": "npx",
+            "args": ["-y", "@anthropic/puppeteer-mcp"],
+            "env": [],
+            "description": "Full browser automation (better than Playwright)",
+        },
+        "sqlite": {
+            "command": "npx",
+            "args": ["-y", "@anthropic/sqlite-mcp"],
+            "env": [],
+            "description": "SQLite database queries",
+        },
+        "postgres": {
+            "command": "npx",
+            "args": ["-y", "@anthropic/postgres-mcp"],
+            "env": ["DATABASE_URL"],
+            "description": "PostgreSQL database queries",
+        },
+        "slack": {
+            "command": "npx",
+            "args": ["-y", "@anthropic/slack-mcp"],
+            "env": ["SLACK_TOKEN"],
+            "description": "Slack: send messages, read channels",
+        },
+    }
+    
+    @classmethod
+    def _load_configs(cls):
+        """Load saved MCP server configs from HF memory."""
+        if cls._loaded:
+            return
+        try:
+            data = memory.read("mcp_servers.json", default={"servers": {}}) or {"servers": {}}
+            cls._servers = data.get("servers", {})
+            cls._loaded = True
+            log(f"MCPClient: loaded {len(cls._servers)} server configs")
+        except Exception:
+            cls._servers = {}
+            cls._loaded = True
+    
+    @classmethod
+    def _save_configs(cls):
+        """Save MCP server configs to HF memory."""
+        try:
+            # Only save configs (not process objects)
+            configs = {}
+            for name, server in cls._servers.items():
+                configs[name] = {
+                    "command": server.get("command"),
+                    "args": server.get("args"),
+                    "env": server.get("env", {}),
+                    "tools": server.get("tools", []),
+                    "connected": server.get("process") is not None,
+                }
+            memory.write("mcp_servers.json", {"servers": configs})
+        except Exception as e:
+            log(f"MCPClient: save failed: {e}")
+    
+    @classmethod
+    def connect(cls, server_name: str, custom_command: str = "", custom_args: str = "") -> str:
+        """Connect to an MCP server.
+        
+        Args:
+            server_name: Name from POPULAR_SERVERS (e.g., "github") or custom name
+            custom_command: Custom command (e.g., "npx", "node", "python")
+            custom_args: Custom args (space-separated)
+        
+        Returns: status message
+        """
+        cls._load_configs()
+        
+        # Check if Node.js is available
+        try:
+            result = subprocess.run(["node", "--version"], capture_output=True, text=True, timeout=5)
+            if result.returncode != 0:
+                return "❌ Node.js is not installed. MCP servers require Node.js."
+        except Exception:
+            return "❌ Node.js is not installed. MCP servers require Node.js."
+        
+        # Determine command and args
+        if server_name in cls.POPULAR_SERVERS and not custom_command:
+            config = cls.POPULAR_SERVERS[server_name]
+            command = config["command"]
+            args = config["args"]
+        elif custom_command:
+            command = custom_command
+            args = custom_args.split() if custom_args else []
+        else:
+            available = ", ".join(cls.POPULAR_SERVERS.keys())
+            return f"❌ Unknown server '{server_name}'. Available: {available}\nOr use: connect to custom mcp: COMMAND ARGS"
+        
+        log(f"MCPClient: connecting to {server_name} ({command} {' '.join(args)})...")
+        
+        # Prepare environment
+        env = os.environ.copy()
+        # Add any required env vars from vault
+        server_config = cls.POPULAR_SERVERS.get(server_name, {})
+        for env_var in server_config.get("env", []):
+            env_key = env_var.lower()
+            if vault.has(env_key):
+                env[env_var] = vault.get(env_key)
+        
+        try:
+            # Spawn the MCP server process
+            process = subprocess.Popen(
+                [command] + args,
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                env=env,
+                text=True,
+                bufsize=1,
+            )
+            
+            # JSON-RPC handshake
+            # Step 1: Send initialize request
+            init_request = {
+                "jsonrpc": "2.0",
+                "id": 1,
+                "method": "initialize",
+                "params": {
+                    "protocolVersion": "2024-11-05",
+                    "capabilities": {},
+                    "clientInfo": {"name": "hermes-agent", "version": "1.0.0"}
+                }
+            }
+            process.stdin.write(json.dumps(init_request) + "\n")
+            process.stdin.flush()
+            
+            # Read response (with timeout)
+            import select
+            readable, _, _ = select.select([process.stdout], [], [], 10)
+            if not readable:
+                process.kill()
+                return f"❌ MCP server '{server_name}' didn't respond (timeout). Check if the package exists."
+            
+            response_line = process.stdout.readline()
+            if not response_line:
+                process.kill()
+                return f"❌ MCP server '{server_name}' closed connection."
+            
+            init_response = json.loads(response_line)
+            if "error" in init_response:
+                process.kill()
+                return f"❌ MCP server '{server_name}' error: {init_response['error']}"
+            
+            # Step 2: Send initialized notification
+            initialized_notif = {
+                "jsonrpc": "2.0",
+                "method": "notifications/initialized",
+            }
+            process.stdin.write(json.dumps(initialized_notif) + "\n")
+            process.stdin.flush()
+            
+            # Step 3: List available tools
+            list_tools_request = {
+                "jsonrpc": "2.0",
+                "id": 2,
+                "method": "tools/list",
+                "params": {}
+            }
+            process.stdin.write(json.dumps(list_tools_request) + "\n")
+            process.stdin.flush()
+            
+            readable, _, _ = select.select([process.stdout], [], [], 5)
+            if not readable:
+                process.kill()
+                return f"❌ MCP server '{server_name}' didn't return tools list."
+            
+            tools_response_line = process.stdout.readline()
+            tools_response = json.loads(tools_response_line)
+            tools = tools_response.get("result", {}).get("tools", [])
+            
+            # Store the server connection
+            cls._servers[server_name] = {
+                "command": command,
+                "args": args,
+                "process": process,
+                "tools": tools,
+                "connected": True,
+            }
+            
+            # Register tools in TOOL_REGISTRY
+            registered = 0
+            for tool in tools:
+                tool_name = f"mcp_{server_name}_{tool['name']}"
+                tool_desc = tool.get("description", "")[:100]
+                # Create a closure to call this tool
+                def make_caller(srv, tn):
+                    def caller(**kwargs):
+                        return cls.call_tool(srv, tn, kwargs)
+                    return caller
+                TOOL_REGISTRY[tool_name] = make_caller(server_name, tool["name"])
+                registered += 1
+            
+            cls._save_configs()
+            log(f"MCPClient: connected to {server_name}, registered {registered} tools")
+            
+            tool_list = "\n".join(f"  • mcp_{server_name}_{t['name']}: {t.get('description','')[:60]}" for t in tools[:10])
+            return (f"✅ Connected to {server_name} MCP server!\n\n"
+                    f"Registered {registered} tools:\n{tool_list}"
+                    f"\n\nYou can now use these tools. Example: 'Use mcp_{server_name}_{tools[0]['name'] if tools else 'tool'}'")
+        
+        except json.JSONDecodeError as e:
+            return f"❌ MCP handshake failed (invalid JSON): {e}"
+        except Exception as e:
+            return f"❌ MCP connection failed: {e}"
+    
+    @classmethod
+    def call_tool(cls, server_name: str, tool_name: str, args: dict) -> str:
+        """Call a tool on an MCP server."""
+        cls._load_configs()
+        server = cls._servers.get(server_name)
+        if not server or not server.get("process"):
+            return f"MCP server '{server_name}' is not connected. Say 'connect to {server_name} mcp' first."
+        
+        process = server["process"]
+        if process.poll() is not None:
+            # Process died — try to reconnect
+            log(f"MCPClient: {server_name} process died, reconnecting...")
+            cls._servers[server_name]["process"] = None
+            reconnect_result = cls.connect(server_name)
+            if "✅" not in reconnect_result:
+                return f"MCP server '{server_name}' disconnected and couldn't reconnect."
+            server = cls._servers.get(server_name)
+            process = server["process"]
+        
+        try:
+            request = {
+                "jsonrpc": "2.0",
+                "id": int(time.time()),
+                "method": "tools/call",
+                "params": {
+                    "name": tool_name,
+                    "arguments": args,
+                }
+            }
+            process.stdin.write(json.dumps(request) + "\n")
+            process.stdin.flush()
+            
+            import select
+            readable, _, _ = select.select([process.stdout], [], [], 30)
+            if not readable:
+                return f"MCP tool '{tool_name}' timed out (30s)."
+            
+            response_line = process.stdout.readline()
+            response = json.loads(response_line)
+            
+            if "error" in response:
+                return f"MCP error: {response['error']}"
+            
+            result = response.get("result", {})
+            # MCP returns content as array of {type, text}
+            content = result.get("content", [])
+            if content:
+                texts = [c.get("text", "") for c in content if c.get("type") == "text"]
+                return "\n".join(texts) if texts else str(result)
+            return str(result)
+        
+        except Exception as e:
+            return f"MCP tool call failed: {e}"
+    
+    @classmethod
+    def disconnect(cls, server_name: str) -> str:
+        """Disconnect from an MCP server."""
+        cls._load_configs()
+        server = cls._servers.get(server_name)
+        if not server:
+            return f"MCP server '{server_name}' not found."
+        
+        process = server.get("process")
+        if process:
+            try:
+                process.kill()
+            except Exception:
+                pass
+        
+        # Remove tools from TOOL_REGISTRY
+        tools_to_remove = [k for k in TOOL_REGISTRY.keys() if k.startswith(f"mcp_{server_name}_")]
+        for t in tools_to_remove:
+            del TOOL_REGISTRY[t]
+        
+        del cls._servers[server_name]
+        cls._save_configs()
+        return f"✅ Disconnected from {server_name} MCP server (removed {len(tools_to_remove)} tools)."
+    
+    @classmethod
+    def list_servers(cls) -> str:
+        """List all available and connected MCP servers."""
+        cls._load_configs()
+        lines = ["🔌 MCP Servers\n"]
+        
+        # Show popular servers
+        lines.append("Available servers (say 'connect to X mcp'):")
+        for name, config in cls.POPULAR_SERVERS.items():
+            connected = "✅" if name in cls._servers and cls._servers[name].get("process") else "⚪"
+            env_req = f" (needs {', '.join(config['env'])})" if config.get("env") else ""
+            lines.append(f"  {connected} {name}: {config['description']}{env_req}")
+        
+        # Show custom connected servers
+        custom = [n for n in cls._servers.keys() if n not in cls.POPULAR_SERVERS]
+        if custom:
+            lines.append(f"\nCustom servers:")
+            for name in custom:
+                lines.append(f"  ✅ {name}")
+        
+        # Show total tools
+        total_tools = sum(len(s.get("tools", [])) for s in cls._servers.values() if s.get("process"))
+        lines.append(f"\nTotal MCP tools available: {total_tools}")
+        
+        return "\n".join(lines)
+
+
 def call_llm_safe(messages, max_tokens=1024, temperature=0.7):
     """BRILLIANT SMART ROUTER v2 — fully uncensored.
     
@@ -6631,6 +7003,28 @@ def detect_intent(text: str, chat_id: str = "default") -> Optional[Dict[str, Any
     if re.search(r"\b(list|show|what)\b.*\b(available\s+)?tools?\b", text_lower):
         return {"action": "list_tools"}
 
+    # 4a-5. MCP commands — connect, disconnect, list MCP servers
+    if "mcp" in text_lower:
+        # Connect: "connect to github mcp" / "connect to filesystem mcp"
+        if re.search(r"\b(connect|start|enable|add)\b.*\b(to\s+)?(\w+)\s+mcp\b", text_lower):
+            match = re.search(r"\b(to\s+)?(\w+)\s+mcp\b", text_lower)
+            server_name = match.group(2) if match else ""
+            return {"action": "mcp_connect", "server_name": server_name}
+        # Custom MCP: "connect to custom mcp: npx some-package"
+        if "custom mcp" in text_lower and ":" in text:
+            parts = text.split(":", 1)
+            if len(parts) >= 2:
+                cmd_parts = parts[1].strip().split(None, 1)
+                return {"action": "mcp_connect_custom", "command": cmd_parts[0] if cmd_parts else "", "args": cmd_parts[1] if len(cmd_parts) > 1 else ""}
+        # Disconnect: "disconnect github mcp" / "remove github mcp"
+        if re.search(r"\b(disconnect|remove|stop|disable)\b.*\b(\w+)\s+mcp\b", text_lower):
+            match = re.search(r"\b(\w+)\s+mcp\b", text_lower)
+            server_name = match.group(1) if match else ""
+            return {"action": "mcp_disconnect", "server_name": server_name}
+        # List: "list mcp servers" / "show mcp"
+        if re.search(r"\b(list|show|available)\b.*mcp", text_lower):
+            return {"action": "mcp_list"}
+
     # 4a-4. Binance API key — special detection (key + secret in same message)
     if "binance" in text_lower and ("key" in text_lower or "api" in text_lower):
         # Binance API keys are 64-char alphanumeric
@@ -6844,6 +7238,29 @@ def execute_action(action: Dict[str, Any], chat_id: str = "default") -> str:
                     f"  • 'Show my BTC order history'\n\n"
                     f"⚠️ I can now trade with your funds. Start with small amounts.")
 
+        # === MCP actions ===
+        if kind == "mcp_connect":
+            server_name = action.get("server_name", "").lower()
+            if not server_name:
+                return "Which MCP server? Say 'list mcp' to see available servers, or 'connect to github mcp'."
+            return MCPClient.connect(server_name)
+        
+        if kind == "mcp_connect_custom":
+            command = action.get("command", "")
+            args = action.get("args", "")
+            if not command:
+                return "Please specify a command. Example: 'connect to custom mcp: npx @some/mcp-server'"
+            return MCPClient.connect("custom", custom_command=command, custom_args=args)
+        
+        if kind == "mcp_disconnect":
+            server_name = action.get("server_name", "").lower()
+            if not server_name:
+                return "Which MCP server? Say 'disconnect github mcp'."
+            return MCPClient.disconnect(server_name)
+        
+        if kind == "mcp_list":
+            return MCPClient.list_servers()
+
         # === Background task actions ===
         if kind == "create_hf_space":
             # Extract chat_id (Telegram user ID) from chat_key like "tg_7475344894"