claude-mpm 4.0.17__py3-none-any.whl → 4.0.20__py3-none-any.whl

claude_mpm/services/mcp_gateway/server/stdio_server.py

@@ -13,9 +13,10 @@ use JSON-RPC protocol, and exit cleanly when stdin closes.
 """
 
 import asyncio
+import json
 import logging
 import sys
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, Optional
 
 # Import MCP SDK components
 from mcp.server import NotificationOptions, Server
@@ -23,6 +24,9 @@ from mcp.server.models import InitializationOptions
 from mcp.server.stdio import stdio_server
 from mcp.types import TextContent, Tool
 
+# Import pydantic for model patching
+from pydantic import BaseModel
+
 from claude_mpm.core.logger import get_logger
 
 # Import unified ticket tool if available
@@ -36,6 +40,75 @@ except ImportError:
     TICKET_TOOLS_AVAILABLE = False
 
 
+def apply_backward_compatibility_patches():
+    """
+    Apply backward compatibility patches for MCP protocol differences.
+    
+    This function patches the MCP Server to handle missing clientInfo
+    in initialize requests from older Claude Desktop versions.
+    """
+    try:
+        from mcp.server import Server
+        
+        logger = get_logger("MCPPatcher")
+        logger.info("Applying MCP Server message handling patch for backward compatibility")
+        
+        # Store the original _handle_message method
+        original_handle_message = Server._handle_message
+        
+        async def patched_handle_message(self, message, session, lifespan_context, raise_exceptions=False):
+            """Patched message handler that adds clientInfo if missing from initialize requests."""
+            try:
+                # Check if this is a request responder with initialize method
+                if hasattr(message, 'request') and hasattr(message.request, 'method'):
+                    request = message.request
+                    if (request.method == 'initialize' and 
+                        hasattr(request, 'params') and 
+                        request.params is not None):
+                        
+                        # Convert params to dict to check for clientInfo
+                        params_dict = request.params
+                        if hasattr(params_dict, 'model_dump'):
+                            params_dict = params_dict.model_dump()
+                        elif hasattr(params_dict, 'dict'):
+                            params_dict = params_dict.dict()
+                        
+                        if isinstance(params_dict, dict) and 'clientInfo' not in params_dict:
+                            logger.info("Adding default clientInfo for backward compatibility")
+                            
+                            # Add default clientInfo
+                            params_dict['clientInfo'] = {
+                                'name': 'claude-desktop',
+                                'version': 'unknown'
+                            }
+                            
+                            # Try to update the params object
+                            if hasattr(request.params, '__dict__'):
+                                request.params.clientInfo = params_dict['clientInfo']
+                            
+                # Call the original handler
+                return await original_handle_message(self, message, session, lifespan_context, raise_exceptions)
+                
+            except Exception as e:
+                logger.warning(f"Error in patched message handler: {e}")
+                # Fall back to original handler
+                return await original_handle_message(self, message, session, lifespan_context, raise_exceptions)
+        
+        # Apply the patch
+        Server._handle_message = patched_handle_message
+        logger.info("Applied MCP Server message handling patch")
+        return True
+        
+    except ImportError as e:
+        get_logger("MCPPatcher").warning(f"Could not import MCP Server for patching: {e}")
+        return False
+    except Exception as e:
+        get_logger("MCPPatcher").error(f"Failed to apply backward compatibility patch: {e}")
+        return False
+
+
+
+
 class SimpleMCPServer:
     """
     A simple stdio-based MCP server implementation.
@@ -48,6 +121,7 @@ class SimpleMCPServer:
     - Spawned on-demand by Claude
     - Communicates via stdin/stdout
     - Exits when connection closes
+    - Includes backward compatibility for protocol differences
     """
 
     def __init__(self, name: str = "claude-mpm-gateway", version: str = "1.0.0"):
@@ -62,6 +136,9 @@ class SimpleMCPServer:
         self.version = version
         self.logger = get_logger("MCPStdioServer")
 
+        # Apply backward compatibility patches before creating server
+        apply_backward_compatibility_patches()
+        
         # Create MCP server instance
         self.server = Server(name)
 
@@ -113,7 +190,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:
         """Create a brief summary by selecting most important sentences."""
         if not sentences:
             return ""
@@ -195,7 +272,7 @@ class SimpleMCPServer:
         return " ".join(s[1] for s in selected)
 
     def _create_detailed_summary(
-        self, sentences: List[str], content: str, max_length: int
+        self, sentences: list[str], content: str, max_length: int
     ) -> str:
         """Create a detailed summary preserving document structure."""
         import re
@@ -226,7 +303,7 @@ class SimpleMCPServer:
         return " ".join(words) + ("..." if len(result.split()) > max_length else "")
 
     def _create_bullet_summary(
-        self, sentences: List[str], content: str, max_length: int
+        self, sentences: list[str], content: str, max_length: int
     ) -> str:
         """Extract key points as a bullet list."""
         import re
@@ -270,7 +347,7 @@ class SimpleMCPServer:
         return "\n".join(result_lines)
 
     def _create_executive_summary(
-        self, sentences: List[str], content: str, max_length: int
+        self, sentences: list[str], content: str, max_length: int
     ) -> str:
         """Create an executive summary with overview, findings, and recommendations."""
         # Allocate words across sections
@@ -356,84 +433,35 @@ class SimpleMCPServer:
         We register them using decorators on handler functions.
         """
         # Initialize unified ticket tool if available
+        # NOTE: Defer initialization to avoid event loop issues
         self.unified_ticket_tool = None
-        if TICKET_TOOLS_AVAILABLE:
-            try:
-                self.unified_ticket_tool = UnifiedTicketTool()
-                # Initialize the unified ticket tool
-                asyncio.create_task(self.unified_ticket_tool.initialize())
-            except Exception as e:
-                self.logger.warning(f"Failed to initialize unified ticket tool: {e}")
-                self.unified_ticket_tool = None
-
+        self._ticket_tool_initialized = False
+        
         @self.server.list_tools()
-        async def handle_list_tools() -> List[Tool]:
+        async def handle_list_tools() -> list[Tool]:
             """List available tools."""
+            # Initialize ticket tool lazily if needed
+            if not self._ticket_tool_initialized and TICKET_TOOLS_AVAILABLE:
+                await self._initialize_ticket_tool()
+            
             tools = [
                 Tool(
-                    name="echo",
-                    description="Echo back the provided message",
-                    inputSchema={
-                        "type": "object",
-                        "properties": {
-                            "message": {
-                                "type": "string",
-                                "description": "Message to echo",
-                            }
-                        },
-                        "required": ["message"],
-                    },
-                ),
-                Tool(
-                    name="calculator",
-                    description="Perform basic arithmetic calculations",
-                    inputSchema={
-                        "type": "object",
-                        "properties": {
-                            "expression": {
-                                "type": "string",
-                                "description": "Mathematical expression to evaluate",
-                            }
-                        },
-                        "required": ["expression"],
-                    },
-                ),
-                Tool(
-                    name="system_info",
-                    description="Get system information",
+                    name="status",
+                    description="Get system and service status information",
                     inputSchema={
                         "type": "object",
                         "properties": {
                             "info_type": {
                                 "type": "string",
-                                "enum": ["platform", "python_version", "cwd"],
-                                "description": "Type of system information to retrieve",
+                                "enum": ["platform", "python_version", "cwd", "all"],
+                                "description": "Type of status information to retrieve (default: all)",
+                                "default": "all",
                             }
                         },
-                        "required": ["info_type"],
-                    },
-                ),
-                Tool(
-                    name="run_command",
-                    description="Execute a shell command",
-                    inputSchema={
-                        "type": "object",
-                        "properties": {
-                            "command": {
-                                "type": "string",
-                                "description": "Shell command to execute",
-                            },
-                            "timeout": {
-                                "type": "number",
-                                "description": "Command timeout in seconds",
-                                "default": 30,
-                            },
-                        },
-                        "required": ["command"],
                     },
                 ),
                 Tool(
-                    name="summarize_document",
+                    name="document_summarizer",
                     description="Summarize documents or text content",
                     inputSchema={
                         "type": "object",
@@ -478,60 +506,17 @@ class SimpleMCPServer:
             self.logger.info(f"Listing {len(tools)} available tools")
             return tools
 
+
         @self.server.call_tool()
         async def handle_call_tool(
             name: str, arguments: Dict[str, Any]
-        ) -> List[TextContent]:
+        ) -> list[TextContent]:
             """Handle tool invocation."""
             self.logger.info(f"Invoking tool: {name} with arguments: {arguments}")
 
             try:
-                if name == "echo":
-                    message = arguments.get("message", "")
-                    result = f"Echo: {message}"
-
-                elif name == "calculator":
-                    expression = arguments.get("expression", "")
-                    try:
-                        # Safe evaluation of mathematical expressions
-                        import ast
-                        import operator as op
-
-                        # Supported operators
-                        ops = {
-                            ast.Add: op.add,
-                            ast.Sub: op.sub,
-                            ast.Mult: op.mul,
-                            ast.Div: op.truediv,
-                            ast.Pow: op.pow,
-                            ast.Mod: op.mod,
-                            ast.USub: op.neg,
-                        }
-
-                        def eval_expr(expr):
-                            """Safely evaluate mathematical expression."""
-
-                            def _eval(node):
-                                if isinstance(node, ast.Constant):
-                                    return node.value
-                                elif isinstance(node, ast.BinOp):
-                                    return ops[type(node.op)](
-                                        _eval(node.left), _eval(node.right)
-                                    )
-                                elif isinstance(node, ast.UnaryOp):
-                                    return ops[type(node.op)](_eval(node.operand))
-                                else:
-                                    raise TypeError(f"Unsupported operation: {node}")
-
-                            return _eval(ast.parse(expr, mode="eval").body)
-
-                        result_value = eval_expr(expression)
-                        result = f"{expression} = {result_value}"
-                    except Exception as e:
-                        result = f"Error evaluating expression: {str(e)}"
-
-                elif name == "system_info":
-                    info_type = arguments.get("info_type", "platform")
+                if name == "status":
+                    info_type = arguments.get("info_type", "all")
 
                     if info_type == "platform":
                         import platform
@@ -545,77 +530,60 @@ class SimpleMCPServer:
                         import os
 
                         result = f"Working Directory: {os.getcwd()}"
+                    elif info_type == "all":
+                        import platform
+                        import sys
+                        import os
+                        import datetime
+                        
+                        result = (
+                            f"=== System Status ===\n"
+                            f"Platform: {platform.system()} {platform.release()}\n"
+                            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"Tools Available: status, document_summarizer{', ticket' if self.unified_ticket_tool else ''}"
+                        )
                     else:
                         result = f"Unknown info type: {info_type}"
 
-                elif name == "run_command":
-                    command = arguments.get("command", "")
-                    timeout = arguments.get("timeout", 30)
-
-                    import shlex
-                    import subprocess
-
-                    try:
-                        # Split command string into a list to avoid shell injection
-                        command_parts = shlex.split(command)
-
-                        # Use create_subprocess_exec instead of create_subprocess_shell
-                        # to prevent command injection vulnerabilities
-                        proc = await asyncio.create_subprocess_exec(
-                            *command_parts,
-                            stdout=subprocess.PIPE,
-                            stderr=subprocess.PIPE,
-                        )
-
-                        stdout, stderr = await asyncio.wait_for(
-                            proc.communicate(), timeout=timeout
-                        )
-
-                        if proc.returncode == 0:
-                            result = (
-                                stdout.decode()
-                                if stdout
-                                else "Command completed successfully"
-                            )
-                        else:
-                            result = f"Command failed with code {proc.returncode}: {stderr.decode()}"
-                    except asyncio.TimeoutError:
-                        result = f"Command timed out after {timeout} seconds"
-                    except ValueError as e:
-                        # Handle shlex parsing errors (e.g., unmatched quotes)
-                        result = f"Invalid command syntax: {str(e)}"
-                    except Exception as e:
-                        result = f"Error running command: {str(e)}"
-
-                elif name == "summarize_document":
+                elif name == "document_summarizer":
                     content = arguments.get("content", "")
                     style = arguments.get("style", "brief")
                     max_length = arguments.get("max_length", 150)
 
                     result = await self._summarize_content(content, style, max_length)
 
-                elif name == "ticket" and self.unified_ticket_tool:
-                    # Handle unified ticket tool invocations
-                    from claude_mpm.services.mcp_gateway.core.interfaces import (
-                        MCPToolInvocation,
-                    )
+                elif name == "ticket":
+                    # Initialize ticket tool lazily if needed
+                    if not self._ticket_tool_initialized and TICKET_TOOLS_AVAILABLE:
+                        await self._initialize_ticket_tool()
+                    
+                    if self.unified_ticket_tool:
+                        # Handle unified ticket tool invocations
+                        from claude_mpm.services.mcp_gateway.core.interfaces import (
+                            MCPToolInvocation,
+                        )
 
-                    invocation = MCPToolInvocation(
-                        tool_name=name,
-                        parameters=arguments,
-                        request_id=f"req_{name}_{id(arguments)}",
-                    )
+                        invocation = MCPToolInvocation(
+                            tool_name=name,
+                            parameters=arguments,
+                            request_id=f"req_{name}_{id(arguments)}",
+                        )
 
-                    tool_result = await self.unified_ticket_tool.invoke(invocation)
+                        tool_result = await self.unified_ticket_tool.invoke(invocation)
 
-                    if tool_result.success:
-                        result = (
-                            tool_result.data
-                            if isinstance(tool_result.data, str)
-                            else str(tool_result.data)
-                        )
+                        if tool_result.success:
+                            result = (
+                                tool_result.data
+                                if isinstance(tool_result.data, str)
+                                else str(tool_result.data)
+                            )
+                        else:
+                            result = f"Error: {tool_result.error}"
                     else:
-                        result = f"Error: {tool_result.error}"
+                        result = "Ticket tool not available"
 
                 else:
                     result = f"Unknown tool: {name}"
@@ -628,12 +596,37 @@ class SimpleMCPServer:
                 self.logger.error(error_msg)
                 return [TextContent(type="text", text=error_msg)]
 
+
+    async def _initialize_ticket_tool(self):
+        """
+        Initialize the unified ticket tool asynchronously.
+        
+        This is called lazily when the tool is first needed,
+        ensuring an event loop is available.
+        """
+        if self._ticket_tool_initialized or not TICKET_TOOLS_AVAILABLE:
+            return
+        
+        try:
+            self.logger.info("Initializing unified ticket tool...")
+            self.unified_ticket_tool = UnifiedTicketTool()
+            # If the tool has an async init method, call it
+            if hasattr(self.unified_ticket_tool, 'initialize'):
+                await self.unified_ticket_tool.initialize()
+            self._ticket_tool_initialized = True
+            self.logger.info("Unified ticket tool initialized successfully")
+        except Exception as e:
+            self.logger.warning(f"Failed to initialize unified ticket tool: {e}")
+            self.unified_ticket_tool = None
+            self._ticket_tool_initialized = True  # Mark as attempted
+
     async def run(self):
         """
-        Run the MCP server using stdio communication.
+        Run the MCP server using stdio communication with backward compatibility.
 
         WHY: This is the main entry point that sets up stdio communication
-        and runs the server until the connection is closed.
+        and runs the server until the connection is closed. The backward
+        compatibility patches are applied during server initialization.
         """
         try:
             self.logger.info(f"Starting {self.name} v{self.version}")
@@ -652,7 +645,7 @@ class SimpleMCPServer:
                     ),
                 )
 
-                # Run the server
+                # Run the server (with patches already applied)
                 await self.server.run(read_stream, write_stream, init_options)
 
             self.logger.info("Server shutting down normally")
@@ -674,7 +667,16 @@ async def main():
         level=logging.INFO,
         format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
         stream=sys.stderr,
+        force=True  # Force reconfiguration even if already configured
     )
+    
+    # Ensure all loggers output to stderr
+    for logger_name in logging.Logger.manager.loggerDict:
+        logger = logging.getLogger(logger_name)
+        for handler in logger.handlers[:]:
+            # Remove any handlers that might write to stdout
+            if hasattr(handler, 'stream') and handler.stream == sys.stdout:
+                logger.removeHandler(handler)
 
     # Create and run server
     server = SimpleMCPServer()
@@ -683,9 +685,15 @@ async def main():
 
 def main_sync():
     """Synchronous entry point for use as a console script."""
+    import os
+    # Disable telemetry by default
+    os.environ.setdefault('DISABLE_TELEMETRY', '1')
     asyncio.run(main())
 
 
 if __name__ == "__main__":
+    import os
+    # Disable telemetry by default
+    os.environ.setdefault('DISABLE_TELEMETRY', '1')
     # Run the async main function
     main_sync()