rootly-mcp-server 1.0.0__py3-none-any.whl → 2.0.1__py3-none-any.whl

rootly_mcp_server/__init__.py

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

rootly_mcp_server/__main__.py

@@ -1,5 +1,8 @@
+#!/usr/bin/env python3
 """
-Command-line interface for starting the Rootly MCP server.
+Rootly MCP Server - Main entry point
+
+This module provides the main entry point for the Rootly MCP Server.
 """
 
 import argparse
@@ -7,8 +10,9 @@ import logging
 import os
 import sys
 from pathlib import Path
+from typing import Optional, List
 
-from .server import RootlyMCPServer
+from .routemap_server import create_rootly_mcp_server
 
 
 def parse_args():
@@ -46,6 +50,27 @@ def parse_args():
         action="store_true",
         help="Enable debug mode (equivalent to --log-level DEBUG)",
     )
+    parser.add_argument(
+        "--base-url",
+        type=str,
+        help="Base URL for the Rootly API. Default: https://api.rootly.com",
+    )
+    parser.add_argument(
+        "--allowed-paths",
+        type=str,
+        help="Comma-separated list of allowed API paths to include",
+    )
+    parser.add_argument(
+        "--hosted",
+        action="store_true",
+        help="Enable hosted mode for remote MCP server",
+    )
+    # Backward compatibility: support deprecated --host argument
+    parser.add_argument(
+        "--host",
+        action="store_true",
+        help="(Deprecated) Use --hosted instead. Enable hosted mode for remote MCP server",
+    )
     return parser.parse_args()
 
 
@@ -67,11 +92,7 @@ def setup_logging(log_level, debug=False):
     
     # Set specific logger levels
     logging.getLogger("rootly_mcp_server").setLevel(numeric_level)
-    logging.getLogger("rootly_mcp_server.server").setLevel(logging.WARNING)  # Reduce server-specific logs
-    
-    # Always set MCP logger to ERROR level to fix Cline UI issue
-    # This prevents INFO logs from causing problems with Cline tool display
-    logging.getLogger("mcp").setLevel(logging.ERROR)
+    logging.getLogger("mcp").setLevel(numeric_level)
     
     # Log the configuration
     logger = logging.getLogger(__name__)
@@ -97,22 +118,69 @@ def check_api_token():
         logger.debug(f"Token starts with: {api_token[:5]}...")
 
 
+# Create the server instance for FastMCP CLI (follows quickstart pattern)
+def get_server():
+    """Get a configured Rootly MCP server instance."""
+    # Get configuration from environment variables
+    swagger_path = os.getenv("ROOTLY_SWAGGER_PATH")
+    server_name = os.getenv("ROOTLY_SERVER_NAME", "Rootly")
+    hosted = os.getenv("ROOTLY_HOSTED", "false").lower() in ("true", "1", "yes")
+    base_url = os.getenv("ROOTLY_BASE_URL")
+    
+    # Parse allowed paths from environment variable
+    allowed_paths = None
+    allowed_paths_env = os.getenv("ROOTLY_ALLOWED_PATHS")
+    if allowed_paths_env:
+        allowed_paths = [path.strip() for path in allowed_paths_env.split(",")]
+    
+    # Create and return the server
+    return create_rootly_mcp_server(
+        swagger_path=swagger_path,
+        name=server_name,
+        allowed_paths=allowed_paths,
+        hosted=hosted,
+        base_url=base_url,
+    )
+
+
+# Create the server instance for FastMCP CLI (follows quickstart pattern)
+mcp = get_server()
+
+
 def main():
-    """Entry point for the Rootly MCP server."""
+    """Main entry point for the Rootly MCP Server."""
     args = parse_args()
     setup_logging(args.log_level, args.debug)
     
     logger = logging.getLogger(__name__)
     logger.info("Starting Rootly MCP Server")
     
+    # Handle backward compatibility for --host argument
+    hosted_mode = args.hosted
+    if args.host:
+        logger.warning("--host argument is deprecated, use --hosted instead")
+        hosted_mode = True
+    
     check_api_token()
     
     try:
+        # Parse allowed paths from command line argument
+        allowed_paths = None
+        if args.allowed_paths:
+            allowed_paths = [path.strip() for path in args.allowed_paths.split(",")]
+        
         logger.info(f"Initializing server with name: {args.name}")
-        server = RootlyMCPServer(swagger_path=args.swagger_path, name=args.name)
+        server = create_rootly_mcp_server(
+            swagger_path=args.swagger_path,
+            name=args.name,
+            allowed_paths=allowed_paths,
+            hosted=hosted_mode,
+            base_url=args.base_url,
+        )
         
         logger.info(f"Running server with transport: {args.transport}...")
         server.run(transport=args.transport)
+        
     except FileNotFoundError as e:
         logger.error(f"File not found: {e}")
         print(f"Error: {e}", file=sys.stderr)
@@ -124,4 +192,4 @@ def main():
 
 
 if __name__ == "__main__":
-    main() 
+    main()

rootly_mcp_server/client.py

@@ -11,10 +11,13 @@ from typing import Optional, Dict, Any, Union
 # Set up logger
 logger = logging.getLogger(__name__)
 
+
 class RootlyClient:
-    def __init__(self, base_url: Optional[str] = None):
+    def __init__(self, base_url: Optional[str] = None, hosted: bool = False):
         self.base_url = base_url or "https://api.rootly.com"
-        self._api_token = self._get_api_token()
+        self.hosted = hosted
+        if not self.hosted:
+            self._api_token = self._get_api_token()
         logger.debug(f"Initialized RootlyClient with base_url: {self.base_url}")
 
     def _get_api_token(self) -> str:
@@ -24,25 +27,39 @@ class RootlyClient:
             raise ValueError("ROOTLY_API_TOKEN environment variable is not set")
         return api_token
 
-    def make_request(self, method: str, path: str, query_params: Optional[Dict[str, Any]] = None, json_data: Optional[Dict[str, Any]] = None, json_api_type: Optional[str] = None) -> str:
+    def make_request(
+        self,
+        method: str,
+        path: str,
+        query_params: Optional[Dict[str, Any]] = None,
+        json_data: Optional[Dict[str, Any]] = None,
+        json_api_type: Optional[str] = None,
+        api_token: Optional[str] = None,
+    ) -> str:
         """
         Make an authenticated request to the Rootly API.
-        
+
         Args:
             method: The HTTP method to use.
             path: The API path.
             query_params: Query parameters for the request.
             json_data: JSON data for the request body.
             json_api_type: If set, use JSON-API format and this type value.
-            
+
         Returns:
             The API response as a JSON string.
         """
+        if self.hosted:
+            if not api_token:
+                return json.dumps({"error": "No API token provided"})
+        else:
+            api_token = self._api_token
+
         # Default headers
         headers = {
-            "Authorization": f"Bearer {self._api_token}",
+            "Authorization": f"Bearer {api_token}",
             "Content-Type": "application/json",
-            "Accept": "application/json"
+            "Accept": "application/json",
         }
 
         # If JSON-API, update headers and wrap payload
@@ -50,30 +67,25 @@ class RootlyClient:
             headers["Content-Type"] = "application/vnd.api+json"
             headers["Accept"] = "application/vnd.api+json"
             if json_data:
-                json_data = {
-                    "data": {
-                        "type": json_api_type,
-                        "attributes": json_data
-                    }
-                }
+                json_data = {"data": {"type": json_api_type, "attributes": json_data}}
             else:
                 json_data = None
 
         # Ensure path starts with a slash
         if not path.startswith("/"):
             path = f"/{path}"
-            
+
         # Ensure path starts with /v1 if not already
         if not path.startswith("/v1"):
             path = f"/v1{path}"
-            
+
         url = f"{self.base_url}{path}"
-        
+
         logger.debug(f"Making {method} request to {url}")
         logger.debug(f"Headers: {headers}")
         logger.debug(f"Query params: {query_params}")
         logger.debug(f"JSON data: {json_data}")
-        
+
         try:
             response = requests.request(
                 method=method.upper(),
@@ -81,17 +93,19 @@ class RootlyClient:
                 headers=headers,
                 params=query_params,
                 json=json_data,
-                timeout=30  # Add a timeout to prevent hanging
+                timeout=30,  # Add a timeout to prevent hanging
             )
-            
+
             # Log the response status and headers
             logger.debug(f"Response status: {response.status_code}")
             logger.debug(f"Response headers: {response.headers}")
-            
+
             # Try to parse the response as JSON
             try:
                 response_json = response.json()
-                logger.debug(f"Response parsed as JSON: {json.dumps(response_json)[:200]}...")
+                logger.debug(
+                    f"Response parsed as JSON: {json.dumps(response_json)[:200]}..."
+                )
                 response.raise_for_status()
                 return json.dumps(response_json, indent=2)
             except ValueError:
@@ -99,20 +113,20 @@ class RootlyClient:
                 logger.debug(f"Response is not JSON: {response.text[:200]}...")
                 response.raise_for_status()
                 return json.dumps({"text": response.text}, indent=2)
-                
+
         except requests.exceptions.RequestException as e:
             logger.error(f"Request failed: {e}")
             error_response = {"error": str(e)}
-            
+
             # Add response details if available
-            if hasattr(e, 'response') and e.response is not None:
+            if hasattr(e, "response") and e.response is not None:
                 try:
                     error_response["status_code"] = e.response.status_code
                     error_response["response_text"] = e.response.text
                 except:
                     pass
-                
+
             return json.dumps(error_response, indent=2)
         except Exception as e:
             logger.error(f"Unexpected error: {e}")
-            return json.dumps({"error": f"Unexpected error: {str(e)}"}, indent=2) 
+            return json.dumps({"error": f"Unexpected error: {str(e)}"}, indent=2)

rootly_mcp_server/routemap_server.py

@@ -0,0 +1,206 @@
+#!/usr/bin/env python3
+"""
+Rootly FastMCP Server (RouteMap Version)
+
+Alternative implementation using FastMCP's RouteMap system for filtering
+instead of pre-filtering the OpenAPI spec.
+"""
+
+import httpx
+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
+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)
+logger = logging.getLogger(__name__)
+
+def create_rootly_mcp_server(
+    swagger_path: Optional[str] = None,
+    name: str = "Rootly API Server (RouteMap Filtered)",
+    allowed_paths: Optional[List[str]] = None,
+    hosted: bool = False,
+    base_url: Optional[str] = None,
+):
+    """Create and configure the Rootly MCP server using RouteMap filtering."""
+    
+    # Get Rootly API token from environment
+    ROOTLY_API_TOKEN = os.getenv("ROOTLY_API_TOKEN")
+    if not ROOTLY_API_TOKEN:
+        raise ValueError("ROOTLY_API_TOKEN environment variable is required")
+    
+    logger.info("Creating authenticated HTTP client...")
+    # Create authenticated HTTP client
+    client = httpx.AsyncClient(
+        base_url=base_url or "https://api.rootly.com",
+        headers={
+            "Authorization": f"Bearer {ROOTLY_API_TOKEN}",
+            "Content-Type": "application/vnd.api+json",
+            "User-Agent": "Rootly-FastMCP-Server/1.0"
+        },
+        timeout=30.0
+    )
+    
+    logger.info("Loading OpenAPI specification...")
+    # Load OpenAPI spec with smart fallback logic
+    openapi_spec = load_rootly_openapi_spec()
+    logger.info("✅ Successfully loaded OpenAPI specification")
+    
+    logger.info("Fixing OpenAPI spec for FastMCP compatibility...")
+    # Fix array types for FastMCP compatibility
+    def fix_array_types(obj):
+        if isinstance(obj, dict):
+            keys_to_process = list(obj.keys())
+            for key in keys_to_process:
+                value = obj[key]
+                if key == 'type' and isinstance(value, list):
+                    non_null_types = [t for t in value if t != 'null']
+                    if len(non_null_types) >= 1:
+                        obj[key] = non_null_types[0]
+                        obj['nullable'] = True
+                else:
+                    fix_array_types(value)
+        elif isinstance(obj, list):
+            for item in obj:
+                fix_array_types(item)
+    
+    fix_array_types(openapi_spec)
+    logger.info("✅ Fixed OpenAPI spec compatibility issues")
+    
+    logger.info("Creating FastMCP server with RouteMap filtering...")
+    
+    # Define custom route maps for filtering specific endpoints
+    route_maps = [
+        # Core incident management
+        RouteMap(
+            pattern=r"^/v1/incidents$",
+            mcp_type=MCPType.TOOL
+        ),
+        RouteMap(
+            pattern=r"^/v1/incidents/\{incident_id\}/alerts$",
+            mcp_type=MCPType.TOOL
+        ),
+        RouteMap(
+            pattern=r"^/v1/incidents/\{incident_id\}/action_items$",
+            mcp_type=MCPType.TOOL
+        ),
+        
+        # Alert management
+        RouteMap(
+            pattern=r"^/v1/alerts$",
+            mcp_type=MCPType.TOOL
+        ),
+        RouteMap(
+            pattern=r"^/v1/alerts/\{id\}$",
+            mcp_type=MCPType.TOOL
+        ),
+        
+        # Configuration entities
+        RouteMap(
+            pattern=r"^/v1/severities(\{id\})?$",
+            mcp_type=MCPType.TOOL
+        ),
+        RouteMap(
+            pattern=r"^/v1/incident_types(\{id\})?$",
+            mcp_type=MCPType.TOOL
+        ),
+        RouteMap(
+            pattern=r"^/v1/functionalities(\{id\})?$",
+            mcp_type=MCPType.TOOL
+        ),
+        
+        # Organization
+        RouteMap(
+            pattern=r"^/v1/teams(\{id\})?$",
+            mcp_type=MCPType.TOOL
+        ),
+        RouteMap(
+            pattern=r"^/v1/users(\{id\}|/me)?$",
+            mcp_type=MCPType.TOOL
+        ),
+        
+        # Infrastructure
+        RouteMap(
+            pattern=r"^/v1/services(\{id\})?$",
+            mcp_type=MCPType.TOOL
+        ),
+        RouteMap(
+            pattern=r"^/v1/environments(\{id\})?$",
+            mcp_type=MCPType.TOOL
+        ),
+        
+        # Action items
+        RouteMap(
+            pattern=r"^/v1/incident_action_items(\{id\})?$",
+            mcp_type=MCPType.TOOL
+        ),
+        
+        # Workflows
+        RouteMap(
+            pattern=r"^/v1/workflows(\{id\})?$",
+            mcp_type=MCPType.TOOL
+        ),
+        RouteMap(
+            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
+        RouteMap(
+            pattern=r".*",
+            mcp_type=MCPType.EXCLUDE
+        )
+    ]
+    
+    # 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
+    )
+    
+    logger.info(f"✅ 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:
+        logger.info("🚀 Starting Rootly FastMCP Server (RouteMap Version)...")
+        mcp = create_rootly_mcp_server()
+        
+        logger.info("🌐 Server starting on stdio transport...")
+        logger.info("Ready for MCP client connections!")
+        
+        # Run the MCP server
+        mcp.run()
+        
+    except KeyboardInterrupt:
+        logger.info("🛑 Server stopped by user")
+    except Exception as e:
+        logger.error(f"❌ Server error: {e}")
+        raise
+
+if __name__ == "__main__":
+    main()