golf-mcp 0.1.9__tar.gz → 0.1.11__tar.gz

{golf_mcp-0.1.9/src/golf_mcp.egg-info → golf_mcp-0.1.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: golf-mcp
-Version: 0.1.9
+Version: 0.1.11
 Summary: Framework for building MCP servers
 Author-email: Antoni Gmitruk <antoni@golf.dev>
 License-Expression: Apache-2.0

{golf_mcp-0.1.9 → golf_mcp-0.1.11}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "golf-mcp"
-version = "0.1.9"
+version = "0.1.11"
 description = "Framework for building MCP servers"
 authors = [
     {name = "Antoni Gmitruk", email = "antoni@golf.dev"}
@@ -64,7 +64,7 @@ golf = ["examples/**/*"]
 
 [tool.poetry]
 name = "golf-mcp"
-version = "0.1.9"
+version = "0.1.11"
 description = "Framework for building MCP servers with zero boilerplate"
 authors = ["Antoni Gmitruk <antoni@golf.dev>"]
 license = "Apache-2.0"

golf_mcp-0.1.11/src/golf/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.11"

{golf_mcp-0.1.9 → golf_mcp-0.1.11}/src/golf/auth/__init__.py

@@ -11,7 +11,7 @@ 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, get_api_key, set_api_key
+from .helpers import get_access_token, get_provider_token, extract_token_from_header, get_api_key, set_api_key, debug_api_key_context
 from .api_key import configure_api_key, get_api_key_config, is_api_key_configured
 
 class AuthConfig:

golf_mcp-0.1.11/src/golf/auth/helpers.py

@@ -0,0 +1,207 @@
+"""Helper functions for working with authentication in MCP context."""
+
+from typing import Optional, Dict, Any
+from contextvars import ContextVar
+
+# Re-export get_access_token from the MCP SDK
+from mcp.server.auth.middleware.auth_context import get_access_token
+
+from .oauth import GolfOAuthProvider
+
+# Context variable to store the active OAuth provider
+_active_golf_oauth_provider: Optional[GolfOAuthProvider] = None
+
+# Context variable to store the current request's API key
+_current_api_key: ContextVar[Optional[str]] = ContextVar('current_api_key', default=None)
+
+def _set_active_golf_oauth_provider(provider: GolfOAuthProvider) -> None:
+    """
+    Sets the active GolfOAuthProvider instance.
+    Should only be called once during server startup.
+    """
+    global _active_golf_oauth_provider
+    _active_golf_oauth_provider = provider
+
+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]
+
+def set_api_key(api_key: Optional[str]) -> None:
+    """Set the API key for the current request context.
+    
+    This is an internal function used by the middleware.
+    
+    Args:
+        api_key: The API key to store in the context
+    """
+    _current_api_key.set(api_key)
+
+def get_api_key() -> Optional[str]:
+    """Get the API key from the current request context.
+    
+    This function should be used in tools to retrieve the API key
+    that was sent in the request headers.
+    
+    Returns:
+        The API key if available, None otherwise
+        
+    Example:
+        # In a tool file
+        from golf.auth import get_api_key
+        
+        async def call_api():
+            api_key = get_api_key()
+            if not api_key:
+                return {"error": "No API key provided"}
+            
+            # Use the API key in your request
+            headers = {"Authorization": f"Bearer {api_key}"}
+            ...
+    """
+    # Try to get directly from HTTP request if available (FastMCP pattern)
+    try:
+        # This follows the FastMCP pattern for accessing HTTP requests
+        from fastmcp.server.dependencies import get_http_request
+        request = get_http_request()
+        
+        if request and hasattr(request, 'state') and hasattr(request.state, 'api_key'):
+            api_key = request.state.api_key
+            return api_key
+        
+        # Get the API key configuration
+        from golf.auth.api_key import get_api_key_config
+        api_key_config = get_api_key_config()
+        
+        if api_key_config and request:
+            # Extract API key from headers
+            header_name = api_key_config.header_name
+            header_prefix = api_key_config.header_prefix
+            
+            # Case-insensitive header lookup
+            api_key = None
+            for k, v in request.headers.items():
+                if k.lower() == header_name.lower():
+                    api_key = v
+                    break
+            
+            # Strip prefix if configured
+            if api_key and header_prefix and api_key.startswith(header_prefix):
+                api_key = api_key[len(header_prefix):]
+            
+            if api_key:
+                return api_key
+    except (ImportError, RuntimeError) as e:
+        # FastMCP not available or not in HTTP context
+        pass
+    except Exception as e:
+        pass
+    
+    # Final fallback: environment variable (for development/testing)
+    import os
+    env_api_key = os.environ.get('API_KEY')
+    if env_api_key:
+        return env_api_key
+    
+    return None
+
+def get_api_key_from_request(request) -> Optional[str]:
+    """Get the API key from a specific request object.
+    
+    This is useful when you have direct access to the request object.
+    
+    Args:
+        request: The Starlette Request object
+        
+    Returns:
+        The API key if available, None otherwise
+    """
+    # Check request state first (set by our middleware)
+    if hasattr(request, 'state') and hasattr(request.state, 'api_key'):
+        return request.state.api_key
+    
+    # Fall back to context variable
+    return _current_api_key.get()
+
+def debug_api_key_context() -> Dict[str, Any]:
+    """Debug function to inspect API key context.
+    
+    Returns a dictionary with debugging information about the current
+    API key context. Useful for troubleshooting authentication issues.
+    
+    Returns:
+        Dictionary with debug information
+    """
+    import asyncio
+    import sys
+    import os
+    
+    debug_info = {
+        "context_var_value": _current_api_key.get(),
+        "has_async_task": False,
+        "task_id": None,
+        "main_module_has_storage": False,
+        "main_module_has_context": False,
+        "request_id_from_context": None,
+        "env_vars": {
+            "API_KEY": bool(os.environ.get('API_KEY')),
+            "GOLF_API_KEY_DEBUG": os.environ.get('GOLF_API_KEY_DEBUG', 'false')
+        }
+    }
+    
+    try:
+        task = asyncio.current_task()
+        if task:
+            debug_info["has_async_task"] = True
+            debug_info["task_id"] = id(task)
+    except:
+        pass
+    
+    try:
+        main_module = sys.modules.get('__main__')
+        if main_module:
+            debug_info["main_module_has_storage"] = hasattr(main_module, 'api_key_storage')
+            debug_info["main_module_has_context"] = hasattr(main_module, 'request_id_context')
+            
+            if hasattr(main_module, 'request_id_context'):
+                request_id_context = getattr(main_module, 'request_id_context')
+                debug_info["request_id_from_context"] = request_id_context.get()
+    except:
+        pass
+    
+    return debug_info 

{golf_mcp-0.1.9 → golf_mcp-0.1.11}/src/golf/cli/main.py

@@ -106,7 +106,7 @@ def build_dev(
     if not project_root:
         console.print("[bold red]Error: No GolfMCP project found in the current directory or any parent directory.[/bold red]")
         console.print("Run 'golf init <project_name>' to create a new project.")
-        track_event("cli_build_failed", {"success": False, "environment": "dev"})
+        track_event("cli_build_failed", {"success": False, "environment": "dev", "error_type": "NoProjectFound", "error_message": "No GolfMCP project found"})
         raise typer.Exit(code=1)
     
     # Load settings from the found project
@@ -124,8 +124,10 @@ def build_dev(
         build_project(project_root, settings, output_dir, build_env="dev", copy_env=True)
         # Track successful build with environment
         track_event("cli_build_success", {"success": True, "environment": "dev"})
-    except Exception:
-        track_event("cli_build_failed", {"success": False, "environment": "dev"})
+    except Exception as e:
+        error_type = type(e).__name__
+        error_message = str(e)
+        track_event("cli_build_failed", {"success": False, "environment": "dev", "error_type": error_type, "error_message": error_message})
         raise
 
 
@@ -142,7 +144,7 @@ def build_prod(
     if not project_root:
         console.print("[bold red]Error: No GolfMCP project found in the current directory or any parent directory.[/bold red]")
         console.print("Run 'golf init <project_name>' to create a new project.")
-        track_event("cli_build_failed", {"success": False, "environment": "prod"})
+        track_event("cli_build_failed", {"success": False, "environment": "prod", "error_type": "NoProjectFound", "error_message": "No GolfMCP project found"})
         raise typer.Exit(code=1)
     
     # Load settings from the found project
@@ -160,8 +162,10 @@ def build_prod(
         build_project(project_root, settings, output_dir, build_env="prod", copy_env=False)
         # Track successful build with environment
         track_event("cli_build_success", {"success": True, "environment": "prod"})
-    except Exception:
-        track_event("cli_build_failed", {"success": False, "environment": "prod"})
+    except Exception as e:
+        error_type = type(e).__name__
+        error_message = str(e)
+        track_event("cli_build_failed", {"success": False, "environment": "prod", "error_type": error_type, "error_message": error_message})
         raise
 
 
@@ -191,7 +195,7 @@ def run(
     if not project_root:
         console.print("[bold red]Error: No GolfMCP project found in the current directory or any parent directory.[/bold red]")
         console.print("Run 'golf init <project_name>' to create a new project.")
-        track_event("cli_run_failed", {"success": False})
+        track_event("cli_run_failed", {"success": False, "error_type": "NoProjectFound", "error_message": "No GolfMCP project found"})
         raise typer.Exit(code=1)
     
     # Load settings from the found project
@@ -207,13 +211,20 @@ def run(
     if not dist_dir.exists():
         if build_first:
             console.print(f"[yellow]Dist directory {dist_dir} not found. Building first...[/yellow]")
-            # Build the project
-            from golf.commands.build import build_project
-            build_project(project_root, settings, dist_dir)
+            try:
+                # Build the project
+                from golf.commands.build import build_project
+                build_project(project_root, settings, dist_dir)
+            except Exception as e:
+                error_type = type(e).__name__
+                error_message = str(e)
+                console.print(f"[bold red]Error building project:[/bold red] {error_message}")
+                track_event("cli_run_failed", {"success": False, "error_type": f"BuildError.{error_type}", "error_message": error_message})
+                raise
         else:
             console.print(f"[bold red]Error: Dist directory {dist_dir} not found.[/bold red]")
             console.print("Run 'golf build' first or use --build to build automatically.")
-            track_event("cli_run_failed", {"success": False})
+            track_event("cli_run_failed", {"success": False, "error_type": "DistNotFound", "error_message": "Dist directory not found"})
             raise typer.Exit(code=1)
     
     try:
@@ -231,13 +242,15 @@ def run(
         if return_code == 0:
             track_event("cli_run_success", {"success": True})
         else:
-            track_event("cli_run_failed", {"success": False})
+            track_event("cli_run_failed", {"success": False, "error_type": "NonZeroExit", "error_message": f"Server exited with code {return_code}"})
         
         # Exit with the same code as the server
         if return_code != 0:
             raise typer.Exit(code=return_code)
-    except Exception:
-        track_event("cli_run_failed", {"success": False})
+    except Exception as e:
+        error_type = type(e).__name__
+        error_message = str(e)
+        track_event("cli_run_failed", {"success": False, "error_type": error_type, "error_message": error_message})
         raise
 
 

{golf_mcp-0.1.9 → golf_mcp-0.1.11}/src/golf/commands/init.py

@@ -9,7 +9,7 @@ from rich.console import Console
 from rich.progress import Progress, SpinnerColumn, TextColumn
 from rich.prompt import Confirm
 
-from golf.core.telemetry import track_event
+from golf.core.telemetry import track_event, track_command
 
 console = Console()
 
@@ -26,72 +26,83 @@ def initialize_project(
         output_dir: Directory where the project will be created
         template: Template to use (basic or api_key)
     """
-    # Validate template
-    valid_templates = ("basic", "api_key")
-    if template not in valid_templates:
-        console.print(f"[bold red]Error:[/bold red] Unknown template '{template}'")
-        console.print(f"Available templates: {', '.join(valid_templates)}")
-        track_event("cli_init_failed", {"success": False})
-        return
-    
-    # Check if directory exists
-    if output_dir.exists():
-        if not output_dir.is_dir():
+    try:
+        # Validate template
+        valid_templates = ("basic", "api_key")
+        if template not in valid_templates:
+            console.print(f"[bold red]Error:[/bold red] Unknown template '{template}'")
+            console.print(f"Available templates: {', '.join(valid_templates)}")
+            track_command("init", success=False, error_type="InvalidTemplate", error_message=f"Unknown template: {template}")
+            return
+        
+        # Check if directory exists
+        if output_dir.exists():
+            if not output_dir.is_dir():
+                console.print(
+                    f"[bold red]Error:[/bold red] '{output_dir}' exists but is not a directory."
+                )
+                track_command("init", success=False, error_type="NotADirectory", error_message="Target exists but is not a directory")
+                return
+            
+            # Check if directory is empty
+            if any(output_dir.iterdir()):
+                if not Confirm.ask(
+                    f"Directory '{output_dir}' is not empty. Continue anyway?",
+                    default=False,
+                ):
+                    console.print("Initialization cancelled.")
+                    track_event("cli_init_cancelled", {"success": False})
+                    return
+        else:
+            # Create the directory
+            output_dir.mkdir(parents=True)
+        
+        # Find template directory within the installed package
+        import golf
+        package_init_file = Path(golf.__file__)
+        # The 'examples' directory is now inside the 'golf' package directory
+        # e.g. golf/examples/basic, so go up one from __init__.py to get to 'golf'
+        template_dir = package_init_file.parent / "examples" / template
+        
+        if not template_dir.exists():
             console.print(
-                f"[bold red]Error:[/bold red] '{output_dir}' exists but is not a directory."
+                f"[bold red]Error:[/bold red] Could not find template '{template}'"
             )
-            track_event("cli_init_failed", {"success": False})
+            track_command("init", success=False, error_type="TemplateNotFound", error_message=f"Template directory not found: {template}")
             return
         
-        # Check if directory is empty
-        if any(output_dir.iterdir()):
-            if not Confirm.ask(
-                f"Directory '{output_dir}' is not empty. Continue anyway?",
-                default=False,
-            ):
-                console.print("Initialization cancelled.")
-                track_event("cli_init_cancelled", {"success": False})
-                return
-    else:
-        # Create the directory
-        output_dir.mkdir(parents=True)
-    
-    # Find template directory within the installed package
-    import golf
-    package_init_file = Path(golf.__file__)
-    # The 'examples' directory is now inside the 'golf' package directory
-    # e.g. golf/examples/basic, so go up one from __init__.py to get to 'golf'
-    template_dir = package_init_file.parent / "examples" / template
-    
-    if not template_dir.exists():
-        console.print(
-            f"[bold red]Error:[/bold red] Could not find template '{template}'"
-        )
-        track_event("cli_init_failed", {"success": False})
-        return
-    
-    # Copy template files
-    with Progress(
-        SpinnerColumn(),
-        TextColumn("[bold green]Creating project structure...[/bold green]"),
-        transient=True,
-    ) as progress:
-        progress.add_task("copying", total=None)
+        # Copy template files
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[bold green]Creating project structure...[/bold green]"),
+            transient=True,
+        ) as progress:
+            progress.add_task("copying", total=None)
+            
+            # Copy directory structure
+            _copy_template(template_dir, output_dir, project_name)
         
-        # Copy directory structure
-        _copy_template(template_dir, output_dir, project_name)
-    
-    # Create virtual environment
-    console.print("[bold green]Project initialized successfully![/bold green]")
-    console.print(f"\nTo get started, run:")
-    console.print(f"  cd {output_dir.name}")
-    console.print(f"  golf build dev")
-    
-    # Track successful initialization
-    track_event("cli_init_success", {
-        "success": True,
-        "template": template
-    })
+        # Create virtual environment
+        console.print("[bold green]Project initialized successfully![/bold green]")
+        console.print(f"\nTo get started, run:")
+        console.print(f"  cd {output_dir.name}")
+        console.print(f"  golf build dev")
+        
+        # Track successful initialization
+        track_event("cli_init_success", {
+            "success": True,
+            "template": template
+        })
+    except Exception as e:
+        # Capture error details for telemetry
+        error_type = type(e).__name__
+        error_message = str(e)
+        
+        console.print(f"[bold red]Error during initialization:[/bold red] {error_message}")
+        track_command("init", success=False, error_type=error_type, error_message=error_message)
+        
+        # Re-raise to maintain existing behavior
+        raise
 
 
 def _copy_template(source_dir: Path, target_dir: Path, project_name: str) -> None:

{golf_mcp-0.1.9 → golf_mcp-0.1.11}/src/golf/core/builder.py

@@ -20,6 +20,7 @@ from golf.core.parser import (
 from golf.core.transformer import transform_component
 from golf.core.builder_auth import generate_auth_code, generate_auth_routes
 from golf.auth import get_auth_config
+from golf.auth.api_key import get_api_key_config
 from golf.core.builder_telemetry import (
     generate_telemetry_imports,
     get_otel_dependencies
@@ -548,8 +549,7 @@ class CodeGenerator:
         # Add imports section for different transport methods
         if self.settings.transport == "sse":
             imports.append("import uvicorn")
-            imports.append("from fastmcp.server.http import create_sse_app")
-        elif self.settings.transport != "stdio":
+        elif self.settings.transport in ["streamable-http", "http"]:
             imports.append("import uvicorn")
                 
         # Get transport-specific configuration
@@ -735,12 +735,6 @@ class CodeGenerator:
         server_code_lines.append(mcp_instance_line)
         server_code_lines.append("")
         
-        # Add any post-init code from auth
-        post_init_code = []
-        if auth_components.get("has_auth") and auth_components.get("post_init_code"):
-            post_init_code.extend(auth_components["post_init_code"])
-            post_init_code.append("")
-
         # Main entry point with transport-specific app initialization
         main_code = [
             "if __name__ == \"__main__\":",
@@ -764,16 +758,46 @@ class CodeGenerator:
         
         # Transport-specific run methods
         if self.settings.transport == "sse":
+            # Check if we need to add API key middleware for SSE
+            api_key_config = get_api_key_config()
+            if auth_components.get("has_auth") and api_key_config:
+                main_code.extend([
+                    "    # For SSE with API key auth, we need to get the app and add middleware",
+                    "    app = mcp.http_app(transport=\"sse\")",
+                    "    app.add_middleware(ApiKeyMiddleware)",
+                ])
+            else:
+                main_code.extend([
+                    "    # For SSE, get the app to add middleware",
+                    "    app = mcp.http_app(transport=\"sse\")",
+                ])
+            
+            # Add OpenTelemetry middleware to the SSE app if enabled
+            if self.settings.opentelemetry_enabled:
+                main_code.extend([
+                    "    # Apply OpenTelemetry middleware to the SSE app",
+                    "    from opentelemetry.instrumentation.asgi import OpenTelemetryMiddleware",
+                    "    app = OpenTelemetryMiddleware(app)",
+                ])
+            
             main_code.extend([
-                "    # For SSE, FastMCP's run method handles auth integration better",
-                "    mcp.run(transport=\"sse\", host=host, port=port, log_level=\"info\")"
+                "    # Run with the configured app",
+                "    uvicorn.run(app, host=host, port=port, log_level=\"info\")"
             ])
-        elif self.settings.transport == "streamable-http":
+        elif self.settings.transport in ["streamable-http", "http"]:
             main_code.extend([
                 "    # Create HTTP app and run with uvicorn",
                 "    app = mcp.http_app()",
             ])
             
+            # Check if we need to add API key middleware
+            api_key_config = get_api_key_config()
+            if auth_components.get("has_auth") and api_key_config:
+                main_code.extend([
+                    "    # Add API key middleware",
+                    "    app.add_middleware(ApiKeyMiddleware)",
+                ])
+            
             # Add OpenTelemetry middleware to the HTTP app if enabled
             if self.settings.opentelemetry_enabled:
                 main_code.extend([
@@ -800,7 +824,6 @@ class CodeGenerator:
             env_section + 
             auth_setup_code +
             server_code_lines +
-            post_init_code +
             component_registrations +
             main_code
         )