rootly-mcp-server 2.0.10__py3-none-any.whl → 2.0.11__py3-none-any.whl

rootly_mcp_server/routemap_server.py

@@ -1,206 +0,0 @@
-#!/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("✅ 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()

rootly_mcp_server/test_client.py

@@ -1,150 +0,0 @@
-#!/usr/bin/env python3
-"""
-Test client for the Rootly MCP Server
-
-This script demonstrates how to use the Rootly MCP Server.
-"""
-
-import asyncio
-import os
-import sys
-from pathlib import Path
-
-# Add the src directory to the Python path
-sys.path.insert(0, str(Path(__file__).parent.parent))
-
-from rootly_mcp_server.server import create_rootly_mcp_server
-
-
-async def test_server():
-    """Test the Rootly MCP server."""
-    print("Creating Rootly MCP Server...")
-    
-    try:
-        # Create the server with a subset of endpoints for testing
-        server = create_rootly_mcp_server(
-            name="TestRootly",
-            allowed_paths=[
-                "/incidents",
-                "/alerts",
-                "/teams",
-                "/services"
-            ],
-            hosted=False  # Use local API token
-        )
-        
-        print("✅ Server created successfully")
-        print(f"Server type: {type(server)}")
-        
-        # Use the get_tools method to access tools
-        try:
-            tools = await server.get_tools()
-            print(f"Tools type: {type(tools)}")
-            print(f"Tools: {tools}")
-            
-            # Handle both dict and list cases
-            if isinstance(tools, dict):
-                tools_list = list(tools.values())
-                tools_names = list(tools.keys())
-                tool_count = len(tools)
-            elif isinstance(tools, list):
-                tools_list = tools
-                tools_names = [getattr(tool, 'name', f'tool_{i}') for i, tool in enumerate(tools)]
-                tool_count = len(tools)
-            else:
-                tools_list = []
-                tools_names = []
-                tool_count = 0
-            
-            print(f"Found {tool_count} tools via get_tools() method")
-            
-            # List the registered tools
-            if tool_count > 0:
-                print(f"\n📋 Registered tools ({tool_count}):")
-                for i, tool in enumerate(tools_list):
-                    if isinstance(tools, dict):
-                        tool_name = tools_names[i]
-                    else:
-                        tool_name = getattr(tool, 'name', f'tool_{i}')
-                    
-                    description = getattr(tool, 'description', 'No description')
-                    print(f"  • {tool_name}: {description[:100]}...")
-                    print(f"    Tool type: {type(tool)}")
-                    print(f"    Tool attributes: {[attr for attr in dir(tool) if not attr.startswith('_')][:10]}")
-                    
-                    # Show parameter schema if available
-                    if hasattr(tool, 'inputSchema') and tool.inputSchema:
-                        props = tool.inputSchema.get('properties', {})
-                        if props:
-                            print(f"    Parameters: {', '.join(props.keys())}")
-            else:
-                print("\n⚠️  No tools found")
-                
-            # Test accessing a specific tool
-            if tool_count > 0:
-                print("\n🔍 Testing tool access...")
-                if isinstance(tools, dict):
-                    first_tool_name = tools_names[0]
-                    first_tool = tools[first_tool_name]
-                else:
-                    first_tool = tools_list[0]
-                    first_tool_name = getattr(first_tool, 'name', 'unknown')
-                
-                print(f"  ✅ First tool: {first_tool_name}")
-                print(f"  Tool details: {first_tool}")
-                
-                # Try to get tools and find the specific tool
-                try:
-                    all_tools = await server.get_tools()
-                    if first_tool_name in all_tools:
-                        retrieved_tool = all_tools[first_tool_name]
-                        print(f"  ✅ Successfully retrieved tool by name: {first_tool_name}")
-                        print(f"  Retrieved tool type: {type(retrieved_tool)}")
-                    else:
-                        print(f"  ❌ Could not find tool by name: {first_tool_name}")
-                except Exception as e:
-                    print(f"  ❌ Error retrieving tools: {e}")
-            
-        except Exception as e:
-            print(f"❌ Error accessing tools: {e}")
-            import traceback
-            traceback.print_exc()
-            tool_count = 0
-        
-        print("\n🎉 Test completed successfully!")
-        print(f"Total tools found: {tool_count}")
-        
-    except Exception as e:
-        print(f"❌ Error creating server: {e}")
-        import traceback
-        traceback.print_exc()
-        return False
-    
-    return True
-
-
-def main():
-    """Main function."""
-    print("Rootly MCP Server Test")
-    print("=" * 50)
-    
-    # Check for API token
-    api_token = os.getenv("ROOTLY_API_TOKEN")
-    if not api_token:
-        print("⚠️  Warning: ROOTLY_API_TOKEN not set. Server will use mock client.")
-    else:
-        print(f"✅ API token found: {api_token[:10]}...")
-    
-    # Run the test
-    success = asyncio.run(test_server())
-    
-    if success:
-        print("\n🎉 All tests passed!")
-        sys.exit(0)
-    else:
-        print("\n❌ Tests failed!")
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main() 

rootly_mcp_server-2.0.10.dist-info/RECORD

@@ -1,13 +0,0 @@
-rootly_mcp_server/__init__.py,sha256=6pLh19IFyqE-Cve9zergkD-X_yApEkInREKmRa73T6s,628
-rootly_mcp_server/__main__.py,sha256=_F4p65_VjnN84RtmEdESVLLH0tO5tL9qBfb2Xdvbj2E,6480
-rootly_mcp_server/client.py,sha256=diIBINJP_z4nnQIAC1b70vQSiHaNojEfUDARC2nrKHU,4681
-rootly_mcp_server/routemap_server.py,sha256=0LfK2EzwkFQF9SpHNvGcca5ZaxkBC80gIdDojE0aUcs,6100
-rootly_mcp_server/server.py,sha256=O31ByNNfKjBmmYY1y_ooPKL12b-PXaM5eNrekXzpURE,24346
-rootly_mcp_server/test_client.py,sha256=Ytd5ZP7vImm12CT97k3p9tlkY_JNcXHSzcGGnHCBqv0,5275
-rootly_mcp_server/utils.py,sha256=NyxdcDiFGlV2a8eBO4lKgZg0D7Gxr6xUIB0YyJGgpPA,4165
-rootly_mcp_server/data/__init__.py,sha256=fO8a0bQnRVEoRMHKvhFzj10bhoaw7VsI51czc2MsUm4,143
-rootly_mcp_server-2.0.10.dist-info/METADATA,sha256=SyvYvw80MbIJVhxXvAG_ai1F9FV9N3qPx9Ls4bj3mbg,6189
-rootly_mcp_server-2.0.10.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-rootly_mcp_server-2.0.10.dist-info/entry_points.txt,sha256=NE33b8VgigVPGBkboyo6pvN1Vz35HZtLybxMO4Q03PI,70
-rootly_mcp_server-2.0.10.dist-info/licenses/LICENSE,sha256=c9w9ZZGl14r54tsP40oaq5adTVX_HMNHozPIH2ymzmw,11341
-rootly_mcp_server-2.0.10.dist-info/RECORD,,