gnosys-strata 1.1.4__py3-none-any.whl

strata/mcp_proxy/transport/base.py

@@ -0,0 +1,104 @@
+"""Abstract base class for MCP transport implementations."""
+
+import logging
+from abc import ABC, abstractmethod
+from contextlib import AsyncExitStack
+from typing import Optional, Tuple
+
+from mcp.client.session import ClientSession
+
+logger = logging.getLogger(__name__)
+
+
+class Transport(ABC):
+    """Abstract base class for MCP transport implementations."""
+
+    def __init__(self):
+        """Initialize the transport."""
+        self._session: Optional[ClientSession] = None
+        self._exit_stack: Optional[AsyncExitStack] = None
+        self._connected: bool = False
+
+    @abstractmethod
+    async def _get_streams(self, exit_stack: AsyncExitStack) -> Tuple:
+        """Get the transport-specific streams.
+
+        Args:
+            exit_stack: AsyncExitStack to manage the streams
+
+        Returns:
+            Tuple of (read_stream, write_stream)
+        """
+    async def initialize(self) -> None:
+        if not self._exit_stack:
+            self._exit_stack = AsyncExitStack()
+        
+        try:
+            # Get transport-specific streams
+            streams = await self._get_streams(self._exit_stack)
+
+            # Create client session (common for all transports)
+            self._session = await self._exit_stack.enter_async_context(
+                ClientSession(streams[0], streams[1])
+            )
+            logger.info("Client session created successfully")
+            # Initialize the session
+            await self._session.initialize()
+
+            self._connected = True
+            logger.info(f"Successfully connected via {self.__class__.__name__}")
+
+        except Exception as e:
+            logger.error(f"Failed to connect via {self.__class__.__name__}: {e}")
+            if self._exit_stack:
+                await self._exit_stack.aclose()
+                self._exit_stack = None
+            raise
+
+    async def connect(self) -> None:
+        """Connect to the MCP server using the specific transport."""
+        if self._connected:
+            return
+
+        await self.initialize()
+
+    async def disconnect(self) -> None:
+        """Disconnect from the MCP server."""
+        if not self._connected:
+            return
+
+        if self._exit_stack:
+            try:
+                await self._exit_stack.aclose()
+            except RuntimeError as e:
+                # Handle cross-task cleanup errors from anyio's CancelScope
+                if "cancel scope" in str(e).lower():
+                    logger.warning(
+                        "Cross-task cleanup detected and handled. "
+                        "This typically happens with pytest fixtures."
+                    )
+                else:
+                    raise
+
+        self._session = None
+        self._exit_stack = None
+        self._connected = False
+
+    def is_connected(self) -> bool:
+        """Check if connected to an MCP server."""
+        return self._connected
+
+    def get_session(self) -> ClientSession:
+        """Get the current client session."""
+        if not self._connected or not self._session:
+            raise RuntimeError("Not connected to an MCP server.")
+        return self._session
+
+    async def __aenter__(self):
+        """Enter async context manager."""
+        await self.connect()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Exit async context manager."""
+        await self.disconnect()

strata/mcp_proxy/transport/http.py

@@ -0,0 +1,80 @@
+"""HTTP and SSE transport implementations for MCP."""
+
+import logging
+from contextlib import AsyncExitStack
+from typing import Dict, Literal, Optional, Tuple
+from urllib.parse import urlparse
+
+from mcp.client.sse import sse_client
+from mcp.client.streamable_http import streamablehttp_client
+
+from strata.mcp_proxy.auth_provider import create_oauth_provider
+from .base import Transport
+
+logger = logging.getLogger(__name__)
+
+class HTTPTransport(Transport):
+    """HTTP/SSE transport for MCP communication."""
+
+    def __init__(
+        self,
+        server_name: str,
+        url: str,
+        mode: Literal["http", "sse"] = "http",
+        headers: Optional[Dict[str, str]] = None,
+        auth: str = "",
+    ):
+        """Initialize HTTP transport.
+
+        Args:
+            url: HTTP/HTTPS URL of the MCP server
+            mode: Transport mode - "http" for request/response, "sse" for server-sent events
+            headers: Optional headers to send with requests
+        """
+        super().__init__()
+        self.server_name = server_name
+        self.url = url
+        self.mode = mode
+        self.headers = headers or {}
+        self.auth = auth
+
+        # Validate URL
+        parsed = urlparse(url)
+        if parsed.scheme not in ("http", "https"):
+            raise ValueError(f"Invalid URL scheme: {parsed.scheme}")
+
+    async def _get_streams(self, exit_stack: AsyncExitStack) -> Tuple:
+        """Get HTTP/SSE transport streams.
+
+        Args:
+            exit_stack: AsyncExitStack to manage the streams
+
+        Returns:
+            Tuple of (read_stream, write_stream)
+        """
+        if self.mode == "sse":
+            # Connect via SSE for server-sent events
+            logger.info(f"Connecting to MCP server via SSE: {self.url}")
+            if self.auth == "oauth":
+                return await exit_stack.enter_async_context(
+                    sse_client(
+                        self.url, headers=self.headers, auth=create_oauth_provider(self.server_name, self.url))
+                )
+            return await exit_stack.enter_async_context(
+                sse_client(self.url, headers=self.headers)
+            )
+        elif self.mode == "http":
+            # Connect via standard HTTP (request/response)
+            logger.info(f"Connecting to MCP server via HTTP: {self.url}")
+            if self.auth == "oauth":
+                return await exit_stack.enter_async_context(
+                    streamablehttp_client(
+                        self.url, headers=self.headers, auth=create_oauth_provider(self.server_name, self.url))
+                )
+            return await exit_stack.enter_async_context(
+                streamablehttp_client(self.url, headers=self.headers)
+            )
+        else:
+            raise ValueError(
+                f"Invalid transport mode: {self.mode}. Use 'http' or 'sse'."
+            )

strata/mcp_proxy/transport/stdio.py

@@ -0,0 +1,69 @@
+"""Stdio transport implementation for MCP."""
+
+import logging
+from contextlib import AsyncExitStack
+from typing import Dict, List, Optional, Tuple
+
+from mcp.client.stdio import StdioServerParameters, stdio_client
+
+from .base import Transport
+
+logger = logging.getLogger(__name__)
+
+
+class StdioTransport(Transport):
+    """Stdio transport for MCP communication."""
+
+    def __init__(
+        self,
+        command: str,
+        args: Optional[List[str]] = None,
+        env: Optional[Dict[str, str]] = None,
+    ):
+        """Initialize stdio transport.
+
+        Args:
+            command: Command to execute (e.g., "docker")
+            args: Command arguments (e.g., ["run", "-i", "--rm", "-e", "GITHUB_PERSONAL_ACCESS_TOKEN", "ghcr.io/github/github-mcp-server"])
+            env: Environment variables to pass to the command (e.g., {"GITHUB_PERSONAL_ACCESS_TOKEN": "${input:github_token}"})
+
+        Example server configuration:
+            "servers": {
+                "github": {
+                    "command": "docker",
+                    "args": [
+                        "run",
+                        "-i",
+                        "--rm",
+                        "-e",
+                        "GITHUB_PERSONAL_ACCESS_TOKEN",
+                        "ghcr.io/github/github-mcp-server"
+                    ],
+                    "env": {
+                        "GITHUB_PERSONAL_ACCESS_TOKEN": "${input:github_token}"
+                    }
+                }
+            }
+        """
+        super().__init__()
+        self.command = command
+        self.args = args or []
+        self.env = env or {}
+
+    async def _get_streams(self, exit_stack: AsyncExitStack) -> Tuple:
+        """Get stdio transport streams.
+
+        Args:
+            exit_stack: AsyncExitStack to manage the streams
+
+        Returns:
+            Tuple of (read_stream, write_stream)
+        """
+        # Create stdio server parameters
+        server_params = StdioServerParameters(
+            command=self.command, args=self.args, env=self.env
+        )
+
+        # Connect via stdio
+        logger.info(f"Connecting to MCP server via stdio: {self.command} {self.args}")
+        return await exit_stack.enter_async_context(stdio_client(server_params))

strata/server.py

@@ -0,0 +1,216 @@
+"""Main server module for Strata MCP Router."""
+
+import asyncio
+import contextlib
+import logging
+import os
+from collections.abc import AsyncIterator
+
+import mcp.types as types
+from mcp.server.lowlevel import Server
+from mcp.server.sse import SseServerTransport
+from mcp.server.stdio import stdio_server
+from mcp.server.streamable_http_manager import StreamableHTTPSessionManager
+from starlette.applications import Starlette
+from starlette.responses import Response
+from starlette.routing import Mount, Route
+from starlette.types import Receive, Scope, Send
+
+from .mcp_client_manager import MCPClientManager
+from .tools import execute_tool, get_tool_definitions
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+MCP_ROUTER_PORT = int(os.getenv("MCP_ROUTER_PORT", "8080"))
+
+# Global client manager
+client_manager = MCPClientManager()
+
+
+@contextlib.asynccontextmanager
+async def config_watching_context():
+    """Shared context manager for config watching in both stdio and HTTP modes."""
+    # JIT mode: Don't connect any servers on startup
+    # Servers connect on-demand via manage_servers tool
+    # Catalog is loaded from disk cache (populated via populate_catalog tool)
+    logger.info("Strata starting in JIT mode - no servers connected on startup")
+    logger.info(f"Catalog has {len(client_manager.catalog.get_all_tools())} cached servers")
+
+    # Create default starsystem set if it doesn't exist
+    if not client_manager.server_list.get_set("starsystem"):
+        default_servers = ["STARSYSTEM", "starship", "starlog", "waypoint", "metastack"]
+        # Only include servers that are actually configured
+        available = [s for s in default_servers if client_manager.server_list.get_server(s)]
+        if available:
+            client_manager.server_list.add_set(
+                "starsystem",
+                available,
+                description="Core compound intelligence: STARSYSTEM wrapper + STARSHIP navigation + STARLOG tracking + WAYPOINT flights + metastack templates"
+            )
+            logger.info(f"Created default 'starsystem' set with: {', '.join(available)}")
+
+    # Start config watching in background
+    def on_config_changed(new_servers):
+        """Handle config changes by syncing the client manager."""
+        logger.info("Config file changed, syncing client manager...")
+
+        async def safe_sync():
+            """Safely sync with config, catching any errors."""
+            try:
+                await client_manager.sync_with_config(new_servers)
+            except Exception as e:
+                logger.error(f"Error during config sync: {e}")
+                # Don't let sync errors crash the server
+
+        # Schedule sync on the event loop
+        asyncio.create_task(safe_sync())
+
+    # Start watching config file for changes
+    watch_task = asyncio.create_task(
+        client_manager.server_list.watch_config(on_config_changed)
+    )
+    logger.info("Config file watching enabled - changes will be auto-synced")
+
+    try:
+        yield
+    finally:
+        logger.info("Shutting down...")
+        # Stop config watching
+        watch_task.cancel()
+        try:
+            await watch_task
+        except asyncio.CancelledError:
+            logger.info("Config watching stopped")  # Expected cancellation, no traceback needed
+        # Clean up client managers
+        await client_manager.disconnect_all()
+
+
+def setup_server_handlers(server: Server) -> None:
+    """Set up shared MCP server handlers for both stdio and HTTP modes."""
+
+    @server.list_tools()
+    async def list_tools() -> list[types.Tool]:
+        """List all available Strata tools."""
+        try:
+            # Get available servers from client manager
+            user_available_servers = list(client_manager.active_clients.keys())
+            return get_tool_definitions(user_available_servers)
+        except Exception:
+            logger.exception("Error listing strata tools")
+            return []
+
+    @server.call_tool(validate_input=False)
+    async def call_tool(name: str, arguments: dict) -> list[types.ContentBlock]:
+        """Call one of the strata tools."""
+        return await execute_tool(name, arguments, client_manager)
+
+
+async def run_stdio_server_async() -> None:
+    """Run the Strata MCP router in stdio mode."""
+
+    # Create server instance
+    server = Server("strata-mcp-stdio")
+
+    # Set up shared handlers
+    setup_server_handlers(server)
+
+    # Use shared config watching context manager
+    logger.info("Strata MCP Router running in stdio mode")
+    async with config_watching_context():
+        async with stdio_server() as (read_stream, write_stream):
+            await server.run(
+                read_stream, write_stream, server.create_initialization_options()
+            )
+
+
+def run_stdio_server() -> int:
+    """Run the stdio server synchronously."""
+    try:
+        asyncio.run(run_stdio_server_async())
+        return 0
+    except KeyboardInterrupt:
+        logger.info("Stdio server stopped by user")
+        return 0
+    except Exception:
+        logger.exception("Error running stdio server")
+        return 1
+
+
+def run_server(port: int, json_response: bool) -> int:
+    """Run the MCP router server with the given configuration."""
+
+    # Create the MCP router server instance
+    app = Server("strata-mcp-server")
+
+    # Set up shared handlers
+    setup_server_handlers(app)
+
+    # Set up SSE transport
+    sse = SseServerTransport("/messages/")
+
+    async def handle_sse(request):
+        logger.info("Handling SSE connection for router")
+
+        try:
+            async with sse.connect_sse(
+                request.scope, request.receive, request._send
+            ) as streams:
+                await app.run(
+                    streams[0], streams[1], app.create_initialization_options()
+                )
+        except Exception as e:
+            logger.error(f"SSE connection error: {e}")
+        return Response()
+
+    # Set up StreamableHTTP transport
+    session_manager = StreamableHTTPSessionManager(
+        app=app,
+        event_store=None,  # Stateless mode
+        json_response=json_response,
+        stateless=True,
+    )
+
+    async def handle_streamable_http(
+        scope: Scope, receive: Receive, send: Send
+    ) -> None:
+        logger.info("Handling StreamableHTTP request for router")
+        try:
+            await session_manager.handle_request(scope, receive, send)
+        finally:
+            logger.info("StreamableHTTP request completed")
+
+    @contextlib.asynccontextmanager
+    async def lifespan(app: Starlette) -> AsyncIterator[None]:
+        """Context manager for session manager and client initialization."""
+        async with config_watching_context():
+            async with session_manager.run():
+                logger.info("Strata MCP Router started with dual transports!")
+                logger.info("Available tools:")
+                logger.info("- discover_server_actions: Discover available actions")
+                logger.info("- get_action_details: Get detailed action parameters")
+                logger.info("- execute_action: Execute server actions")
+                logger.info("- search_documentation: Search server documentation")
+                logger.info("- handle_auth_failure: Handle authentication issues")
+                yield
+
+    # Create an ASGI application with routes for both transports
+    starlette_app = Starlette(
+        debug=True,
+        routes=[
+            # SSE routes
+            Route("/sse", endpoint=handle_sse, methods=["GET"]),
+            Mount("/messages/", app=sse.handle_post_message),
+            # StreamableHTTP route
+            Mount("/mcp", app=handle_streamable_http),
+        ],
+        lifespan=lifespan,
+    )
+
+    logger.info(f"Strata MCP Router starting on port {port} with dual transports")
+
+    import uvicorn
+
+    uvicorn.run(starlette_app, host="0.0.0.0", port=port)
+
+    return 0