rootly-mcp-server 2.0.6__py3-none-any.whl → 2.0.9__py3-none-any.whl

rootly_mcp_server/__init__.py

@@ -13,7 +13,7 @@ Features:
 from .server import RootlyMCPServer
 from .client import RootlyClient
 
-__version__ = "2.0.0"
+__version__ = "2.0.1"
 __all__ = [
     'RootlyMCPServer',
     'RootlyClient',

rootly_mcp_server/__main__.py

@@ -10,9 +10,7 @@ import logging
 import os
 import sys
 from pathlib import Path
-from typing import Optional, List
-
-from .routemap_server import create_rootly_mcp_server
+from .server import create_rootly_mcp_server
 
 
 def parse_args():
@@ -137,7 +135,7 @@ def get_server():
     return create_rootly_mcp_server(
         swagger_path=swagger_path,
         name=server_name,
-        custom_allowed_paths=allowed_paths,
+        allowed_paths=allowed_paths,
         hosted=hosted,
         base_url=base_url,
     )
@@ -161,7 +159,9 @@ def main():
         logger.warning("--host argument is deprecated, use --hosted instead")
         hosted_mode = True
     
-    check_api_token()
+    # Only check API token if not in hosted mode
+    if not hosted_mode:
+        check_api_token()
     
     try:
         # Parse allowed paths from command line argument
@@ -173,7 +173,7 @@ def main():
         server = create_rootly_mcp_server(
             swagger_path=args.swagger_path,
             name=args.name,
-            custom_allowed_paths=allowed_paths,
+            allowed_paths=allowed_paths,
             hosted=hosted_mode,
             base_url=args.base_url,
         )

rootly_mcp_server/client.py

@@ -6,7 +6,7 @@ import os
 import json
 import logging
 import requests
-from typing import Optional, Dict, Any, Union
+from typing import Optional, Dict, Any
 
 # Set up logger
 logger = logging.getLogger(__name__)
@@ -123,7 +123,7 @@ class RootlyClient:
                 try:
                     error_response["status_code"] = e.response.status_code
                     error_response["response_text"] = e.response.text
-                except:
+                except Exception:
                     pass
 
             return json.dumps(error_response, indent=2)

rootly_mcp_server/routemap_server.py

@@ -2,7 +2,8 @@
 """
 Rootly FastMCP Server (RouteMap Version)
 
-Working implementation using FastMCP's RouteMap system with proper response handling.
+Alternative implementation using FastMCP's RouteMap system for filtering
+instead of pre-filtering the OpenAPI spec.
 """
 
 import httpx
@@ -10,10 +11,13 @@ from fastmcp import FastMCP
 from fastmcp.server.openapi import RouteMap, MCPType
 import os
 import logging
+import sys
+from pathlib import Path
 from typing import Optional, List
 
 # Import the shared OpenAPI loader
-from .rootly_openapi_loader import load_rootly_openapi_spec
+sys.path.append(str(Path(__file__).parent.parent.parent))
+from rootly_openapi_loader import load_rootly_openapi_spec
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
@@ -22,7 +26,7 @@ logger = logging.getLogger(__name__)
 def create_rootly_mcp_server(
     swagger_path: Optional[str] = None,
     name: str = "Rootly API Server (RouteMap Filtered)",
-    custom_allowed_paths: Optional[List[str]] = None,
+    allowed_paths: Optional[List[str]] = None,
     hosted: bool = False,
     base_url: Optional[str] = None,
 ):
@@ -34,79 +38,8 @@ def create_rootly_mcp_server(
         raise ValueError("ROOTLY_API_TOKEN environment variable is required")
     
     logger.info("Creating authenticated HTTP client...")
-    # Create a custom HTTP client wrapper that ensures string responses
-    class StringifyingClient:
-        def __init__(self, base_url: str, headers: dict, timeout: float):
-            self._client = httpx.AsyncClient(
-                base_url=base_url,
-                headers=headers,
-                timeout=timeout
-            )
-        
-        async def __aenter__(self):
-            await self._client.__aenter__()
-            return self
-        
-        async def __aexit__(self, exc_type, exc_val, exc_tb):
-            await self._client.__aexit__(exc_type, exc_val, exc_tb)
-        
-        async def request(self, method: str, url: str, **kwargs):
-            """Override request to return responses that FastMCP can handle."""
-            response = await self._client.request(method, url, **kwargs)
-            
-            # Create a response that returns the raw text instead of structured JSON
-            class TextResponse:
-                def __init__(self, original_response):
-                    self.status_code = original_response.status_code
-                    self.headers = original_response.headers
-                    self.url = original_response.url
-                    self.request = original_response.request
-                    self._original = original_response
-                    
-                    # Pre-compute the text response
-                    if original_response.status_code == 200:
-                        try:
-                            import json
-                            data = original_response.json()
-                            self._text_response = json.dumps(data, indent=2)
-                        except Exception:
-                            self._text_response = original_response.text or "No content"
-                    else:
-                        self._text_response = f"Error: HTTP {original_response.status_code} - {original_response.text}"
-                
-                def json(self):
-                    """Return the original JSON data for structured_content."""
-                    try:
-                        # Return the original JSON data so FastMCP can handle structured_content
-                        return self._original.json()
-                    except Exception:
-                        # If JSON parsing fails, return a wrapper structure
-                        return {"result": self._text_response}
-                
-                @property
-                def text(self):
-                    """Return the formatted JSON as text."""
-                    return self._text_response
-                
-                @property
-                def content(self):
-                    return self._text_response.encode('utf-8')
-                
-                def raise_for_status(self):
-                    """Delegate to original response."""
-                    return self._original.raise_for_status()
-                
-                def __getattr__(self, name):
-                    """Delegate any missing attributes to original response."""
-                    return getattr(self._original, name)
-            
-            return TextResponse(response)
-        
-        def __getattr__(self, name):
-            return getattr(self._client, name)
-    
-    # Create authenticated HTTP client with string conversion
-    client = StringifyingClient(
+    # Create authenticated HTTP client
+    client = httpx.AsyncClient(
         base_url=base_url or "https://api.rootly.com",
         headers={
             "Authorization": f"Bearer {ROOTLY_API_TOKEN}",
@@ -146,89 +79,84 @@ def create_rootly_mcp_server(
     
     # Define custom route maps for filtering specific endpoints
     route_maps = [
-        # Core incident management - list endpoints
+        # Core incident management
         RouteMap(
             pattern=r"^/v1/incidents$",
-            mcp_type=MCPType.TOOL,
-            mcp_tags={"incidents", "core", "list"}
+            mcp_type=MCPType.TOOL
         ),
-        # Incident detail endpoints  
         RouteMap(
-            pattern=r"^/v1/incidents/\{.*\}$",
-            mcp_type=MCPType.TOOL,
-            mcp_tags={"incidents", "detail"}
+            pattern=r"^/v1/incidents/\{incident_id\}/alerts$",
+            mcp_type=MCPType.TOOL
         ),
-        # Incident relationships
         RouteMap(
-            pattern=r"^/v1/incidents/\{.*\}/.*$",
-            mcp_type=MCPType.TOOL,
-            mcp_tags={"incidents", "relationships"}
+            pattern=r"^/v1/incidents/\{incident_id\}/action_items$",
+            mcp_type=MCPType.TOOL
         ),
         
         # Alert management
         RouteMap(
             pattern=r"^/v1/alerts$",
-            mcp_type=MCPType.TOOL,
-            mcp_tags={"alerts", "core", "list"}
+            mcp_type=MCPType.TOOL
         ),
         RouteMap(
-            pattern=r"^/v1/alerts/\{.*\}$",
-            mcp_type=MCPType.TOOL,
-            mcp_tags={"alerts", "detail"}
+            pattern=r"^/v1/alerts/\{id\}$",
+            mcp_type=MCPType.TOOL
         ),
         
-        # Users - both list and detail
+        # Configuration entities
         RouteMap(
-            pattern=r"^/v1/users$",
-            mcp_type=MCPType.TOOL,
-            mcp_tags={"users", "list"}
+            pattern=r"^/v1/severities(\{id\})?$",
+            mcp_type=MCPType.TOOL
         ),
         RouteMap(
-            pattern=r"^/v1/users/me$",
-            mcp_type=MCPType.TOOL,
-            mcp_tags={"users", "current"}
+            pattern=r"^/v1/incident_types(\{id\})?$",
+            mcp_type=MCPType.TOOL
         ),
         RouteMap(
-            pattern=r"^/v1/users/\{.*\}$",
-            mcp_type=MCPType.TOOL,
-            mcp_tags={"users", "detail"}
+            pattern=r"^/v1/functionalities(\{id\})?$",
+            mcp_type=MCPType.TOOL
         ),
         
-        # Teams
+        # Organization
         RouteMap(
-            pattern=r"^/v1/teams$",
-            mcp_type=MCPType.TOOL,
-            mcp_tags={"teams", "list"}
+            pattern=r"^/v1/teams(\{id\})?$",
+            mcp_type=MCPType.TOOL
         ),
         RouteMap(
-            pattern=r"^/v1/teams/\{.*\}$",
-            mcp_type=MCPType.TOOL,
-            mcp_tags={"teams", "detail"}
+            pattern=r"^/v1/users(\{id\}|/me)?$",
+            mcp_type=MCPType.TOOL
         ),
         
-        # Services
+        # Infrastructure
+        RouteMap(
+            pattern=r"^/v1/services(\{id\})?$",
+            mcp_type=MCPType.TOOL
+        ),
         RouteMap(
-            pattern=r"^/v1/services$",
-            mcp_type=MCPType.TOOL,
-            mcp_tags={"services", "list"}
+            pattern=r"^/v1/environments(\{id\})?$",
+            mcp_type=MCPType.TOOL
         ),
+        
+        # Action items
         RouteMap(
-            pattern=r"^/v1/services/\{.*\}$",
-            mcp_type=MCPType.TOOL,
-            mcp_tags={"services", "detail"}
+            pattern=r"^/v1/incident_action_items(\{id\})?$",
+            mcp_type=MCPType.TOOL
         ),
         
-        # Configuration entities - list patterns
+        # Workflows
         RouteMap(
-            pattern=r"^/v1/(severities|incident_types|environments)$",
-            mcp_type=MCPType.TOOL,
-            mcp_tags={"configuration", "list"}
+            pattern=r"^/v1/workflows(\{id\})?$",
+            mcp_type=MCPType.TOOL
         ),
-        # Configuration entities - detail patterns  
         RouteMap(
-            pattern=r"^/v1/(severities|incident_types|environments)/\{.*\}$",
-            mcp_type=MCPType.TOOL,
-            mcp_tags={"configuration", "detail"}
+            pattern=r"^/v1/workflow_runs(\{id\})?$",
+            mcp_type=MCPType.TOOL
+        ),
+        
+        # Status pages
+        RouteMap(
+            pattern=r"^/v1/status_pages(\{id\})?$",
+            mcp_type=MCPType.TOOL
         ),
         
         # Exclude everything else
@@ -238,37 +166,24 @@ def create_rootly_mcp_server(
         )
     ]
     
-    # Custom response handler to ensure proper MCP output format
-    def ensure_mcp_response(route, component):
-        """Ensure all responses work with FastMCP's structured content system."""
-        # Set output schema to handle structured JSON data
-        component.output_schema = {
-            "type": "object",
-            "description": "Rootly API response data",
-            "additionalProperties": True
-        }
-        
-        # Add description 
-        if hasattr(component, 'description'):
-            component.description = f"🔧 {component.description or 'Rootly API endpoint'}"
-    
-    # Create MCP server with custom route maps and response handling
+    # Create MCP server with custom route maps
     mcp = FastMCP.from_openapi(
         openapi_spec=openapi_spec,
         client=client,
         name=name,
         timeout=30.0,
         tags={"rootly", "incident-management", "evaluation"},
-        route_maps=route_maps,
-        mcp_component_fn=ensure_mcp_response
+        route_maps=route_maps
     )
     
-    logger.info(f"✅ Created MCP server with RouteMap filtering successfully")
+    logger.info("✅ Created MCP server with RouteMap filtering successfully")
     logger.info("🚀 Selected Rootly API endpoints are now available as MCP tools")
     
     return mcp
 
 
+
+
 def main():
     """Main entry point."""
     try: