golf-mcp 0.1.0__py3-none-any.whl

golf/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0" # Placeholder version 

golf/auth/__init__.py

@@ -0,0 +1,109 @@
+"""Authentication module for GolfMCP servers.
+
+This module provides a simple API for configuring OAuth authentication
+for GolfMCP servers. Users can configure authentication in their pre_build.py
+file without needing to understand the complexities of the MCP SDK.
+"""
+
+from typing import List, Optional, Tuple
+
+from mcp.server.auth.settings import AuthSettings, ClientRegistrationOptions
+
+from .provider import ProviderConfig
+from .oauth import GolfOAuthProvider, create_callback_handler
+from .helpers import get_access_token, get_provider_token, extract_token_from_header
+
+class AuthConfig:
+    """Configuration for OAuth authentication in GolfMCP."""
+    
+    def __init__(
+        self, 
+        provider_config: ProviderConfig,
+        required_scopes: List[str],
+        callback_path: str = "/auth/callback",
+        login_path: str = "/login",
+        error_path: str = "/auth-error"
+    ):
+        """Initialize authentication configuration.
+        
+        Args:
+            provider_config: Configuration for the OAuth provider
+            required_scopes: Scopes required for all authenticated requests
+            callback_path: Path for the OAuth callback
+            login_path: Path for the login redirect
+            error_path: Path for displaying authentication errors
+        """
+        self.provider_config = provider_config
+        self.required_scopes = required_scopes
+        self.callback_path = callback_path
+        self.login_path = login_path
+        self.error_path = error_path
+        
+        # Create the OAuth provider
+        self.provider = GolfOAuthProvider(provider_config)
+        
+        # Create auth settings for FastMCP
+        self.auth_settings = AuthSettings(
+            issuer_url=provider_config.issuer_url or "http://localhost:3000",
+            client_registration_options=ClientRegistrationOptions(
+                enabled=True,
+                valid_scopes=provider_config.scopes,
+                default_scopes=provider_config.scopes
+            ),
+            required_scopes=required_scopes or provider_config.scopes
+        )
+
+# Global state for the build process
+_auth_config: Optional[AuthConfig] = None
+
+def configure_auth(
+    provider_config=None,
+    provider=None,
+    required_scopes: Optional[List[str]] = None,
+    callback_path: str = "/auth/callback",
+) -> None:
+    """Configure authentication for a GolfMCP server.
+    
+    This function should be called in pre_build.py to set up authentication.
+    
+    Args:
+        provider_config: Configuration for the OAuth provider (new parameter name)
+        provider: Configuration for the OAuth provider (old parameter name, deprecated)
+        required_scopes: Scopes required for authentication
+        callback_path: Path for the OAuth callback
+        public_paths: List of paths that don't require authentication (deprecated, no longer used)
+    """
+    global _auth_config
+    
+    # Handle backward compatibility with old parameter name
+    if provider_config is None and provider is not None:
+        provider_config = provider
+    elif provider_config is None and provider is None:
+        raise ValueError("Either provider_config or provider must be provided")
+    
+    _auth_config = AuthConfig(
+        provider_config=provider_config,
+        required_scopes=required_scopes or provider_config.scopes,
+        callback_path=callback_path
+    )
+
+def get_auth_config() -> Tuple[Optional[ProviderConfig], List[str]]:
+    """Get the current authentication configuration.
+    
+    Returns:
+        Tuple of (provider_config, required_scopes)
+    """
+    if _auth_config:
+        return _auth_config.provider_config, _auth_config.required_scopes
+    return None, []
+
+def create_auth_provider() -> Optional[GolfOAuthProvider]:
+    """Create an OAuth provider from the configured provider settings.
+    
+    Returns:
+        GolfOAuthProvider instance or None if not configured
+    """
+    if not _auth_config:
+        return None
+        
+    return _auth_config.provider 

golf/auth/helpers.py

@@ -0,0 +1,56 @@
+"""Helper functions for working with authentication in MCP context."""
+
+from typing import Optional
+
+# Re-export get_access_token from the MCP SDK
+from mcp.server.auth.middleware.auth_context import get_access_token
+
+_active_golf_oauth_provider = None
+
+def _set_active_golf_oauth_provider(provider_instance) -> None:
+    """
+    Sets the active GolfOAuthProvider instance.
+    Should only be called once during server startup.
+    """
+    global _active_golf_oauth_provider
+    _active_golf_oauth_provider = provider_instance
+
+def get_provider_token() -> Optional[str]:
+    """
+    Get a provider token (e.g., GitHub token) associated with the current
+    MCP session's access token.
+
+    This relies on _set_active_golf_oauth_provider being called at server startup.
+    """
+    mcp_access_token = get_access_token() # From MCP SDK, uses its own ContextVar
+    if not mcp_access_token:
+        # No active MCP session token.
+        return None
+
+    provider = _active_golf_oauth_provider
+    if not provider:
+        return None
+    
+    if not hasattr(provider, "get_provider_token"):
+        return None
+
+    # Call the get_provider_token method on the actual GolfOAuthProvider instance
+    return provider.get_provider_token(mcp_access_token.token)
+
+def extract_token_from_header(auth_header: str) -> Optional[str]:
+    """Extract bearer token from Authorization header.
+
+    Args:
+        auth_header: Authorization header value
+
+    Returns:
+        Bearer token or None if not present/valid
+    """
+    if not auth_header:
+        return None
+
+    parts = auth_header.split()
+    if len(parts) != 2 or parts[0].lower() != 'bearer':
+        return None
+
+    return parts[1]