claude-mpm 4.3.11__py3-none-any.whl → 4.3.13__py3-none-any.whl

claude_mpm/services/mcp_gateway/server/mcp_gateway.py

@@ -16,7 +16,7 @@ import asyncio
 import contextlib
 import json
 import traceback
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Any, Callable, Dict, List, Optional, Union
 
 # Import from the official MCP package
@@ -148,7 +148,7 @@ class MCPGateway(BaseMCPService, IMCPGateway):
             invocation = MCPToolInvocation(
                 tool_name=name,
                 parameters=arguments,
-                request_id=f"req_{datetime.now().timestamp()}",
+                request_id=f"req_{datetime.now(timezone.utc).timestamp()}",
             )
 
             try:
@@ -212,7 +212,7 @@ class MCPGateway(BaseMCPService, IMCPGateway):
                 self.log_warning("No tool registry set - server will have no tools")
 
             # Initialize metrics
-            self._metrics["start_time"] = datetime.now().isoformat()
+            self._metrics["start_time"] = datetime.now(timezone.utc).isoformat()
 
             # Update capabilities based on registry
             if self._tool_registry:
@@ -287,7 +287,7 @@ class MCPGateway(BaseMCPService, IMCPGateway):
         try:
             # Update metrics
             self._metrics["requests_handled"] += 1
-            self._metrics["last_request_time"] = datetime.now().isoformat()
+            self._metrics["last_request_time"] = datetime.now(timezone.utc).isoformat()
 
             # Extract request details
             method = request.get("method", "")

claude_mpm/services/mcp_gateway/server/stdio_handler.py

@@ -139,7 +139,7 @@ class StdioHandler(BaseMCPService, IMCPCommunication):
             self._metrics["errors"] += 1
             raise
 
-    async def receive_message(self) -> Optional[Dict[str, Any]]:
+    async def receive_message(self) -> Optional[Dict[str, Any]]:  # noqa: PLR0911
         """
         Receive a message from the MCP client via stdin.
 

claude_mpm/services/mcp_gateway/server/stdio_server.py

@@ -17,6 +17,7 @@ import logging
 import os
 import sys
 import time
+from datetime import timezone
 from typing import Any, Dict
 
 # Import MCP SDK components
@@ -172,7 +173,7 @@ class SimpleMCPServer:
 
     async def _summarize_content(
         self, content: str, style: str, max_length: int
-    ) -> str:
+    ) -> str:  # noqa: PLR0911
         """
         Summarize text content based on style and length constraints.
 
@@ -214,7 +215,7 @@ class SimpleMCPServer:
         # Default to brief
         return self._create_brief_summary(sentences, max_length)
 
-    def _create_brief_summary(self, sentences: list[str], max_length: int) -> str:
+    def _create_brief_summary(self, sentences: list[str], max_length: int) -> str:  # noqa: PLR0911
         """Create a brief summary by selecting most important sentences."""
         if not sentences:
             return ""
@@ -562,7 +563,7 @@ class SimpleMCPServer:
                             f"Python: {sys.version.split()[0]}\n"
                             f"Working Directory: {os.getcwd()}\n"
                             f"Server: {self.name} v{self.version}\n"
-                            f"Timestamp: {datetime.datetime.now().isoformat()}\n"
+                            f"Timestamp: {datetime.datetime.now(timezone.utc).isoformat()}\n"
                             f"Tools Available: status, document_summarizer{', ticket' if self.unified_ticket_tool else ''}"
                         )
                     else:

claude_mpm/services/mcp_gateway/tools/base_adapter.py

@@ -8,7 +8,7 @@ Part of ISS-0035: MCP Server Implementation - Core Server and Tool Registry
 """
 
 from abc import ABC
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import Any, Dict
 
 from claude_mpm.services.mcp_gateway.core.base import BaseMCPService
@@ -195,7 +195,7 @@ class BaseToolAdapter(BaseMCPService, IMCPToolAdapter, ABC):
         self._metrics["average_execution_time"] = (
             self._metrics["total_execution_time"] / self._metrics["invocations"]
         )
-        self._metrics["last_invocation"] = datetime.now().isoformat()
+        self._metrics["last_invocation"] = datetime.now(timezone.utc).isoformat()
 
 
 class EchoToolAdapter(BaseToolAdapter):
@@ -235,7 +235,7 @@ class EchoToolAdapter(BaseToolAdapter):
         Returns:
             Tool execution result with echoed message
         """
-        start_time = datetime.now()
+        start_time = datetime.now(timezone.utc)
 
         try:
             # Get parameters
@@ -246,7 +246,7 @@ class EchoToolAdapter(BaseToolAdapter):
             result = message.upper() if uppercase else message
 
             # Calculate execution time
-            execution_time = (datetime.now() - start_time).total_seconds()
+            execution_time = (datetime.now(timezone.utc) - start_time).total_seconds()
 
             # Update metrics
             self._update_metrics(True, execution_time)
@@ -259,7 +259,7 @@ class EchoToolAdapter(BaseToolAdapter):
             )
 
         except Exception as e:
-            execution_time = (datetime.now() - start_time).total_seconds()
+            execution_time = (datetime.now(timezone.utc) - start_time).total_seconds()
             self._update_metrics(False, execution_time)
             self._metrics["last_error"] = str(e)
 
@@ -321,7 +321,7 @@ class CalculatorToolAdapter(BaseToolAdapter):
         Returns:
             Tool execution result with calculation
         """
-        start_time = datetime.now()
+        start_time = datetime.now(timezone.utc)
 
         try:
             # Get parameters
@@ -348,7 +348,7 @@ class CalculatorToolAdapter(BaseToolAdapter):
                 raise ValueError(f"Unknown operation: {operation}")
 
             # Calculate execution time
-            execution_time = (datetime.now() - start_time).total_seconds()
+            execution_time = (datetime.now(timezone.utc) - start_time).total_seconds()
 
             # Update metrics
             self._update_metrics(True, execution_time)
@@ -361,7 +361,7 @@ class CalculatorToolAdapter(BaseToolAdapter):
             )
 
         except Exception as e:
-            execution_time = (datetime.now() - start_time).total_seconds()
+            execution_time = (datetime.now(timezone.utc) - start_time).total_seconds()
             self._update_metrics(False, execution_time)
             self._metrics["last_error"] = str(e)
 
@@ -408,7 +408,7 @@ class SystemInfoToolAdapter(BaseToolAdapter):
         Returns:
             Tool execution result with system information
         """
-        start_time = datetime.now()
+        start_time = datetime.now(timezone.utc)
 
         try:
             import platform
@@ -443,15 +443,15 @@ class SystemInfoToolAdapter(BaseToolAdapter):
                 }
             elif info_type == "time":
                 result = {
-                    "current": datetime.now().isoformat(),
-                    "timestamp": datetime.now().timestamp(),
-                    "timezone": str(datetime.now().astimezone().tzinfo),
+                    "current": datetime.now(timezone.utc).isoformat(),
+                    "timestamp": datetime.now(timezone.utc).timestamp(),
+                    "timezone": str(datetime.now(timezone.utc).astimezone().tzinfo),
                 }
             else:
                 raise ValueError(f"Unknown info type: {info_type}")
 
             # Calculate execution time
-            execution_time = (datetime.now() - start_time).total_seconds()
+            execution_time = (datetime.now(timezone.utc) - start_time).total_seconds()
 
             # Update metrics
             self._update_metrics(True, execution_time)
@@ -465,7 +465,7 @@ class SystemInfoToolAdapter(BaseToolAdapter):
 
         except ImportError as e:
             # Handle missing psutil dependency gracefully
-            execution_time = (datetime.now() - start_time).total_seconds()
+            execution_time = (datetime.now(timezone.utc) - start_time).total_seconds()
             self._update_metrics(False, execution_time)
 
             return MCPToolResult(
@@ -474,7 +474,7 @@ class SystemInfoToolAdapter(BaseToolAdapter):
                 execution_time=execution_time,
             )
         except Exception as e:
-            execution_time = (datetime.now() - start_time).total_seconds()
+            execution_time = (datetime.now(timezone.utc) - start_time).total_seconds()
             self._update_metrics(False, execution_time)
             self._metrics["last_error"] = str(e)
 

claude_mpm/services/mcp_gateway/tools/document_summarizer.py

@@ -13,7 +13,7 @@ import mimetypes
 import os
 import re
 from collections import OrderedDict
-from datetime import datetime
+from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple
 
@@ -605,7 +605,7 @@ class DocumentSummarizerTool(BaseToolAdapter):
         Returns:
             Tool execution result with summary
         """
-        start_time = datetime.now()
+        start_time = datetime.now(timezone.utc)
 
         try:
             # Get parameters
@@ -628,7 +628,9 @@ class DocumentSummarizerTool(BaseToolAdapter):
                 cached_result = self._cache.get(cache_key)
                 if cached_result:
                     cache_hit = True
-                    execution_time = (datetime.now() - start_time).total_seconds()
+                    execution_time = (
+                        datetime.now(timezone.utc) - start_time
+                    ).total_seconds()
                     self._update_metrics(True, execution_time)
 
                     return MCPToolResult(
@@ -709,7 +711,7 @@ class DocumentSummarizerTool(BaseToolAdapter):
                 self._cache.put(cache_key, result.copy(), summary_size)
 
             # Calculate execution time
-            execution_time = (datetime.now() - start_time).total_seconds()
+            execution_time = (datetime.now(timezone.utc) - start_time).total_seconds()
 
             # Update metrics
             self._update_metrics(True, execution_time)
@@ -730,7 +732,7 @@ class DocumentSummarizerTool(BaseToolAdapter):
             )
 
         except Exception as e:
-            execution_time = (datetime.now() - start_time).total_seconds()
+            execution_time = (datetime.now(timezone.utc) - start_time).total_seconds()
             self._update_metrics(False, execution_time)
             self._metrics["last_error"] = str(e)
 

claude_mpm/services/mcp_gateway/tools/external_mcp_services.py

@@ -0,0 +1,443 @@
+"""
+External MCP Services Integration
+==================================
+
+Manages installation and basic setup of external MCP services like mcp-vector-search
+and mcp-browser. These services run as separate MCP servers in Claude Desktop,
+not as part of the Claude MPM MCP Gateway.
+
+Note: As of the latest architecture, external services are registered as separate
+MCP servers in Claude Desktop configuration, not as tools within the gateway.
+"""
+
+import json
+import subprocess
+import sys
+from pathlib import Path
+from typing import Any, Dict, List
+
+from claude_mpm.services.mcp_gateway.tools.base_adapter import BaseMCPToolAdapter
+
+
+class ExternalMCPService(BaseMCPToolAdapter):
+    """Base class for external MCP service integration."""
+
+    def __init__(self, service_name: str, package_name: str):
+        """
+        Initialize external MCP service.
+
+        Args:
+            service_name: Name of the service for MCP
+            package_name: Python package name to install/run
+        """
+        super().__init__()
+        self.service_name = service_name
+        self.package_name = package_name
+        self.process = None
+        self._is_installed = False
+
+    async def initialize(self) -> bool:
+        """Initialize the external service."""
+        try:
+            # Check if package is installed
+            self._is_installed = await self._check_installation()
+
+            if not self._is_installed:
+                self.logger.warning(
+                    f"{self.package_name} not installed, attempting installation..."
+                )
+                await self._install_package()
+                self._is_installed = await self._check_installation()
+
+            if not self._is_installed:
+                self.logger.error(f"Failed to install {self.package_name}")
+                return False
+
+            self.logger.info(f"{self.package_name} is available")
+            return True
+
+        except Exception as e:
+            self.logger.error(f"Failed to initialize {self.service_name}: {e}")
+            return False
+
+    async def _check_installation(self) -> bool:
+        """Check if the package is installed."""
+        try:
+            result = subprocess.run(
+                [sys.executable, "-m", self.package_name.replace("-", "_"), "--help"],
+                capture_output=True,
+                text=True,
+                timeout=5,
+                check=False,
+            )
+            return result.returncode == 0
+        except (
+            subprocess.TimeoutExpired,
+            FileNotFoundError,
+            subprocess.CalledProcessError,
+        ):
+            return False
+
+    async def _install_package(self) -> bool:
+        """Install the package using pip."""
+        try:
+            self.logger.info(f"Installing {self.package_name}...")
+            result = subprocess.run(
+                [sys.executable, "-m", "pip", "install", self.package_name],
+                capture_output=True,
+                text=True,
+                timeout=30,
+                check=False,
+            )
+
+            if result.returncode == 0:
+                self.logger.info(f"Successfully installed {self.package_name}")
+                return True
+            self.logger.error(f"Failed to install {self.package_name}: {result.stderr}")
+            return False
+
+        except Exception as e:
+            self.logger.error(f"Error installing {self.package_name}: {e}")
+            return False
+
+    def get_definition(self) -> Dict[str, Any]:
+        """Get service definition for MCP registration."""
+        return {
+            "name": self.service_name,
+            "description": f"External MCP service: {self.package_name}",
+            "type": "external_service",
+            "package": self.package_name,
+            "installed": self._is_installed,
+        }
+
+
+class MCPVectorSearchService(ExternalMCPService):
+    """MCP Vector Search service integration."""
+
+    def __init__(self):
+        """Initialize MCP Vector Search service."""
+        super().__init__("mcp-vector-search", "mcp-vector-search")
+
+    def get_definition(self) -> Dict[str, Any]:
+        """Get tool definition for MCP registration."""
+        base_def = super().get_definition()
+        base_def.update(
+            {
+                "description": "Semantic code search powered by vector embeddings",
+                "tools": [
+                    {
+                        "name": "mcp__mcp-vector-search__search_code",
+                        "description": "Search for code using semantic similarity",
+                        "inputSchema": {
+                            "type": "object",
+                            "properties": {
+                                "query": {
+                                    "type": "string",
+                                    "description": "The search query",
+                                },
+                                "limit": {"type": "integer", "default": 10},
+                                "similarity_threshold": {
+                                    "type": "number",
+                                    "default": 0.3,
+                                },
+                                "language": {"type": "string"},
+                                "file_extensions": {
+                                    "type": "array",
+                                    "items": {"type": "string"},
+                                },
+                                "files": {"type": "string"},
+                                "class_name": {"type": "string"},
+                                "function_name": {"type": "string"},
+                            },
+                            "required": ["query"],
+                        },
+                    },
+                    {
+                        "name": "mcp__mcp-vector-search__search_similar",
+                        "description": "Find code similar to a specific file or function",
+                        "inputSchema": {
+                            "type": "object",
+                            "properties": {
+                                "file_path": {
+                                    "type": "string",
+                                    "description": "Path to the file",
+                                },
+                                "function_name": {"type": "string"},
+                                "limit": {"type": "integer", "default": 10},
+                                "similarity_threshold": {
+                                    "type": "number",
+                                    "default": 0.3,
+                                },
+                            },
+                            "required": ["file_path"],
+                        },
+                    },
+                    {
+                        "name": "mcp__mcp-vector-search__search_context",
+                        "description": "Search for code based on contextual description",
+                        "inputSchema": {
+                            "type": "object",
+                            "properties": {
+                                "description": {
+                                    "type": "string",
+                                    "description": "Contextual description",
+                                },
+                                "focus_areas": {
+                                    "type": "array",
+                                    "items": {"type": "string"},
+                                },
+                                "limit": {"type": "integer", "default": 10},
+                            },
+                            "required": ["description"],
+                        },
+                    },
+                    {
+                        "name": "mcp__mcp-vector-search__get_project_status",
+                        "description": "Get project indexing status and statistics",
+                        "inputSchema": {
+                            "type": "object",
+                            "properties": {},
+                            "required": [],
+                        },
+                    },
+                    {
+                        "name": "mcp__mcp-vector-search__index_project",
+                        "description": "Index or reindex the project codebase",
+                        "inputSchema": {
+                            "type": "object",
+                            "properties": {
+                                "force": {"type": "boolean", "default": False},
+                                "file_extensions": {
+                                    "type": "array",
+                                    "items": {"type": "string"},
+                                },
+                            },
+                            "required": [],
+                        },
+                    },
+                ],
+            }
+        )
+        return base_def
+
+    async def invoke(self, tool_name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """Invoke a tool from mcp-vector-search."""
+        try:
+            # Extract the actual tool name (remove prefix)
+            actual_tool = tool_name.replace("mcp__mcp-vector-search__", "")
+
+            # Prepare the command
+            cmd = [
+                sys.executable,
+                "-m",
+                "mcp_vector_search",
+                "--tool",
+                actual_tool,
+                "--args",
+                json.dumps(arguments),
+            ]
+
+            # Run the command
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=30,
+                cwd=Path.cwd(),
+                check=False,  # Use current working directory for project context
+            )
+
+            if result.returncode == 0:
+                try:
+                    return json.loads(result.stdout)
+                except json.JSONDecodeError:
+                    return {"result": result.stdout}
+            else:
+                return {"error": result.stderr or "Tool invocation failed"}
+
+        except subprocess.TimeoutExpired:
+            return {"error": "Tool invocation timed out"}
+        except Exception as e:
+            return {"error": str(e)}
+
+
+class MCPBrowserService(ExternalMCPService):
+    """MCP Browser service integration."""
+
+    def __init__(self):
+        """Initialize MCP Browser service."""
+        super().__init__("mcp-browser", "mcp-browser")
+
+    def get_definition(self) -> Dict[str, Any]:
+        """Get tool definition for MCP registration."""
+        base_def = super().get_definition()
+        base_def.update(
+            {
+                "description": "Web browsing and content extraction capabilities",
+                "tools": [
+                    {
+                        "name": "mcp__mcp-browser__browse",
+                        "description": "Browse a webpage and extract content",
+                        "inputSchema": {
+                            "type": "object",
+                            "properties": {
+                                "url": {
+                                    "type": "string",
+                                    "description": "URL to browse",
+                                },
+                                "extract": {
+                                    "type": "string",
+                                    "description": "What to extract",
+                                },
+                            },
+                            "required": ["url"],
+                        },
+                    },
+                    {
+                        "name": "mcp__mcp-browser__search",
+                        "description": "Search the web",
+                        "inputSchema": {
+                            "type": "object",
+                            "properties": {
+                                "query": {
+                                    "type": "string",
+                                    "description": "Search query",
+                                },
+                                "num_results": {"type": "integer", "default": 10},
+                            },
+                            "required": ["query"],
+                        },
+                    },
+                    {
+                        "name": "mcp__mcp-browser__screenshot",
+                        "description": "Take a screenshot of a webpage",
+                        "inputSchema": {
+                            "type": "object",
+                            "properties": {
+                                "url": {
+                                    "type": "string",
+                                    "description": "URL to screenshot",
+                                },
+                                "full_page": {"type": "boolean", "default": False},
+                            },
+                            "required": ["url"],
+                        },
+                    },
+                ],
+            }
+        )
+        return base_def
+
+    async def invoke(self, tool_name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """Invoke a tool from mcp-browser."""
+        try:
+            # Extract the actual tool name (remove prefix)
+            actual_tool = tool_name.replace("mcp__mcp-browser__", "")
+
+            # Prepare the command
+            cmd = [
+                sys.executable,
+                "-m",
+                "mcp_browser",
+                "--tool",
+                actual_tool,
+                "--args",
+                json.dumps(arguments),
+            ]
+
+            # Run the command
+            result = subprocess.run(
+                cmd, capture_output=True, text=True, timeout=30, check=False
+            )
+
+            if result.returncode == 0:
+                try:
+                    return json.loads(result.stdout)
+                except json.JSONDecodeError:
+                    return {"result": result.stdout}
+            else:
+                return {"error": result.stderr or "Tool invocation failed"}
+
+        except subprocess.TimeoutExpired:
+            return {"error": "Tool invocation timed out"}
+        except Exception as e:
+            return {"error": str(e)}
+
+
+class ExternalMCPServiceManager:
+    """Manager for external MCP services.
+
+    This manager is responsible for checking and installing Python packages
+    for external MCP services. The actual registration of these services
+    happens in Claude Desktop configuration as separate MCP servers.
+
+    Note: This class is maintained for backward compatibility and package
+    management. The actual tool registration is handled by separate MCP
+    server instances in Claude Desktop.
+    """
+
+    def __init__(self):
+        """Initialize the service manager."""
+        self.services: List[ExternalMCPService] = []
+        self.logger = None
+
+    async def initialize_services(self) -> List[ExternalMCPService]:
+        """Initialize all external MCP services.
+
+        This method checks if external service packages are installed
+        and attempts to install them if missing. It does NOT register
+        them as tools in the gateway - they run as separate MCP servers.
+        """
+        # Create service instances
+        services = [MCPVectorSearchService(), MCPBrowserService()]
+
+        # Initialize each service
+        initialized_services = []
+        for service in services:
+            try:
+                if await service.initialize():
+                    initialized_services.append(service)
+                    if self.logger:
+                        self.logger.info(
+                            f"Initialized external service: {service.service_name}"
+                        )
+                elif self.logger:
+                    self.logger.warning(f"Failed to initialize: {service.service_name}")
+            except Exception as e:
+                if self.logger:
+                    self.logger.error(f"Error initializing {service.service_name}: {e}")
+
+        self.services = initialized_services
+        return initialized_services
+
+    def get_all_tools(self) -> List[Dict[str, Any]]:
+        """Get all tool definitions from external services."""
+        all_tools = []
+        for service in self.services:
+            service_def = service.get_definition()
+            if "tools" in service_def:
+                all_tools.extend(service_def["tools"])
+        return all_tools
+
+    async def invoke_tool(
+        self, tool_name: str, arguments: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """Invoke a tool from any registered external service."""
+        # Find the service that handles this tool
+        for service in self.services:
+            if tool_name.startswith(f"mcp__{service.service_name}__"):
+                if isinstance(service, (MCPVectorSearchService, MCPBrowserService)):
+                    return await service.invoke(tool_name, arguments)
+
+        return {"error": f"No service found for tool: {tool_name}"}
+
+    async def shutdown(self):
+        """Shutdown all external services."""
+        for service in self.services:
+            try:
+                await service.shutdown()
+            except Exception as e:
+                if self.logger:
+                    self.logger.warning(
+                        f"Error shutting down {service.service_name}: {e}"
+                    )