golf-mcp 0.1.20__py3-none-any.whl → 0.2.1__py3-none-any.whl

golf/auth/registry.py

@@ -0,0 +1,256 @@
+"""Provider registry system for extensible authentication providers.
+
+This module provides a registry-based dispatch system that allows custom
+authentication providers to be added without modifying the core factory code.
+"""
+
+from typing import Protocol, TYPE_CHECKING
+from abc import ABC, abstractmethod
+
+if TYPE_CHECKING:
+    from fastmcp.server.auth.auth import AuthProvider
+
+from .providers import AuthConfig
+
+
+class AuthProviderFactory(Protocol):
+    """Protocol for auth provider factory functions.
+
+    Custom provider factories must implement this interface to be compatible
+    with the registry system.
+    """
+
+    def __call__(self, config: AuthConfig) -> "AuthProvider":
+        """Create an AuthProvider from configuration.
+
+        Args:
+            config: Authentication configuration object
+
+        Returns:
+            Configured FastMCP AuthProvider instance
+
+        Raises:
+            ValueError: If configuration is invalid
+            ImportError: If required dependencies are missing
+        """
+        ...
+
+
+class BaseProviderPlugin(ABC):
+    """Base class for auth provider plugins.
+
+    Provider plugins can extend this class to provide both configuration
+    and factory logic in a single cohesive unit.
+    """
+
+    @property
+    @abstractmethod
+    def provider_type(self) -> str:
+        """Return the provider type identifier."""
+        ...
+
+    @property
+    @abstractmethod
+    def config_class(self) -> type[AuthConfig]:
+        """Return the configuration class for this provider."""
+        ...
+
+    @abstractmethod
+    def create_provider(self, config: AuthConfig) -> "AuthProvider":
+        """Create the auth provider from configuration.
+
+        Args:
+            config: Authentication configuration (must be instance of config_class)
+
+        Returns:
+            Configured FastMCP AuthProvider instance
+        """
+        ...
+
+    def validate_config(self, config: AuthConfig) -> None:
+        """Validate the configuration before creating provider.
+
+        Override this method to add custom validation logic.
+        Default implementation checks config is correct type.
+
+        Args:
+            config: Configuration to validate
+
+        Raises:
+            ValueError: If configuration is invalid
+        """
+        if not isinstance(config, self.config_class):
+            raise ValueError(
+                f"Expected {self.config_class.__name__} for {self.provider_type} provider, got {type(config).__name__}"
+            )
+
+
+class AuthProviderRegistry:
+    """Registry for authentication provider factories and plugins.
+
+    This registry allows custom authentication providers to be registered
+    without modifying the core factory code. Providers can be registered
+    either as simple factory functions or as full plugin classes.
+    """
+
+    def __init__(self) -> None:
+        self._factories: dict[str, AuthProviderFactory] = {}
+        self._plugins: dict[str, BaseProviderPlugin] = {}
+
+    def register_factory(self, provider_type: str, factory: AuthProviderFactory) -> None:
+        """Register a factory function for a provider type.
+
+        Args:
+            provider_type: Unique identifier for the provider type
+            factory: Factory function that creates providers
+
+        Raises:
+            ValueError: If provider_type is already registered
+        """
+        if provider_type in self._factories or provider_type in self._plugins:
+            raise ValueError(f"Provider type '{provider_type}' is already registered")
+
+        self._factories[provider_type] = factory
+
+    def register_plugin(self, plugin: BaseProviderPlugin) -> None:
+        """Register a provider plugin.
+
+        Args:
+            plugin: Provider plugin instance
+
+        Raises:
+            ValueError: If provider type is already registered
+        """
+        provider_type = plugin.provider_type
+        if provider_type in self._factories or provider_type in self._plugins:
+            raise ValueError(f"Provider type '{provider_type}' is already registered")
+
+        self._plugins[provider_type] = plugin
+
+    def unregister(self, provider_type: str) -> None:
+        """Unregister a provider type.
+
+        Args:
+            provider_type: Provider type to remove
+
+        Raises:
+            KeyError: If provider type is not registered
+        """
+        if provider_type in self._factories:
+            del self._factories[provider_type]
+        elif provider_type in self._plugins:
+            del self._plugins[provider_type]
+        else:
+            raise KeyError(f"Provider type '{provider_type}' is not registered")
+
+    def get_factory(self, provider_type: str) -> AuthProviderFactory:
+        """Get factory function for a provider type.
+
+        Args:
+            provider_type: Provider type to look up
+
+        Returns:
+            Factory function for the provider type
+
+        Raises:
+            KeyError: If provider type is not registered
+        """
+        # Check factories first
+        if provider_type in self._factories:
+            return self._factories[provider_type]
+
+        # Check plugins
+        if provider_type in self._plugins:
+            plugin = self._plugins[provider_type]
+
+            # Wrap plugin method to match factory signature
+            def plugin_factory(config: AuthConfig) -> "AuthProvider":
+                plugin.validate_config(config)
+                return plugin.create_provider(config)
+
+            return plugin_factory
+
+        raise KeyError(f"No provider registered for type '{provider_type}'")
+
+    def create_provider(self, config: AuthConfig) -> "AuthProvider":
+        """Create a provider from configuration using the registry.
+
+        Args:
+            config: Authentication configuration
+
+        Returns:
+            Configured AuthProvider instance
+
+        Raises:
+            KeyError: If provider type is not registered
+            ValueError: If configuration is invalid
+        """
+        provider_type = getattr(config, "provider_type", None)
+        if not provider_type:
+            raise ValueError(f"Configuration {type(config).__name__} missing provider_type attribute")
+
+        factory = self.get_factory(provider_type)
+        return factory(config)
+
+    def list_providers(self) -> list[str]:
+        """List all registered provider types.
+
+        Returns:
+            List of provider type identifiers
+        """
+        return sorted(list(self._factories.keys()) + list(self._plugins.keys()))
+
+    def is_registered(self, provider_type: str) -> bool:
+        """Check if a provider type is registered.
+
+        Args:
+            provider_type: Provider type to check
+
+        Returns:
+            True if provider type is registered
+        """
+        return provider_type in self._factories or provider_type in self._plugins
+
+
+# Global registry instance
+_default_registry = AuthProviderRegistry()
+
+
+def get_provider_registry() -> AuthProviderRegistry:
+    """Get the default provider registry.
+
+    Returns:
+        Default AuthProviderRegistry instance
+    """
+    return _default_registry
+
+
+def register_provider_factory(provider_type: str, factory: AuthProviderFactory) -> None:
+    """Register a factory function in the default registry.
+
+    Args:
+        provider_type: Unique identifier for the provider type
+        factory: Factory function that creates providers
+    """
+    _default_registry.register_factory(provider_type, factory)
+
+
+def register_provider_plugin(plugin: BaseProviderPlugin) -> None:
+    """Register a provider plugin in the default registry.
+
+    Args:
+        plugin: Provider plugin instance
+    """
+    _default_registry.register_plugin(plugin)
+
+
+def create_auth_provider_from_registry(config: AuthConfig) -> "AuthProvider":
+    """Create an auth provider using the default registry.
+
+    Args:
+        config: Authentication configuration
+
+    Returns:
+        Configured AuthProvider instance
+    """
+    return _default_registry.create_provider(config)

golf/cli/branding.py

@@ -0,0 +1,192 @@
+"""Golf CLI branding and visual utilities."""
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+from rich.align import Align
+
+# Golf brand colors (official brand colors)
+GOLF_BLUE = "#2969FD"  # Primary blue from brand: rgb(41, 105, 253)
+GOLF_ORANGE = "#F97728"  # Secondary orange from brand: rgb(249, 119, 40)
+GOLF_GREEN = "#10B981"  # Success green
+GOLF_WHITE = "#FFFFFF"
+
+# Simple GolfMCP text logo
+GOLF_LOGO = """
+ ██████╗  ██████╗ ██╗     ███████╗███╗   ███╗ ██████╗██████╗ 
+██╔════╝ ██╔═══██╗██║     ██╔════╝████╗ ████║██╔════╝██╔══██╗
+██║  ███╗██║   ██║██║     █████╗  ██╔████╔██║██║     ██████╔╝
+██║   ██║██║   ██║██║     ██╔══╝  ██║╚██╔╝██║██║     ██╔═══╝ 
+╚██████╔╝╚██████╔╝███████╗██║     ██║ ╚═╝ ██║╚██████╗██║     
+ ╚═════╝  ╚═════╝ ╚══════╝╚═╝     ╚═╝     ╚═╝ ╚═════╝╚═╝     
+"""
+
+# Simplified version for smaller spaces
+GOLF_LOGO_SMALL = "Golf"
+
+# Status icons with consistent styling
+STATUS_ICONS = {
+    "success": "✓",
+    "error": "✗",
+    "warning": "⚠",
+    "info": "ℹ",
+    "building": "🔨",
+    "generating": "⚙️",
+    "packaging": "📦",
+    "platform": "⛳",
+    "server": "🚀",
+    "loading": "⭕",
+}
+
+
+def create_welcome_banner(version: str, console: Console) -> None:
+    """Create the main Golf welcome banner."""
+    # Create the logo with Golf in blue and MCP in orange
+    logo_lines = GOLF_LOGO.strip().split("\n")
+    logo_content = Text()
+
+    for line in logo_lines:
+        if line.strip():  # Only process non-empty lines
+            # Find where "MCP" starts (roughly at position 32 in the ASCII art)
+            golf_part = line[:32]  # First part is "Golf"
+            mcp_part = line[32:]  # Last part is "MCP"
+
+            logo_content.append(golf_part, style=f"bold {GOLF_BLUE}")
+            logo_content.append(mcp_part, style=f"bold {GOLF_ORANGE}")
+        logo_content.append("\n")
+
+    # Create version line
+    version_text = Text()
+    version_text.append("🚀 ", style=f"bold {GOLF_ORANGE}")
+    version_text.append(f"Golf v{version}", style=f"bold {GOLF_BLUE}")
+    version_text.append(" 🚀", style=f"bold {GOLF_ORANGE}")
+
+    # Create tagline
+    tagline_text = Text("✨ Easiest way to build production-ready MCP servers ✨", style="bold white")
+
+    # Create the full content using a renderable group approach
+    from rich.console import Group
+
+    content_group = Group(
+        Align.center(logo_content),
+        "",  # Empty line for spacing
+        Align.center(version_text),
+        Align.center(tagline_text),
+    )
+
+    panel = Panel(
+        content_group,
+        border_style=GOLF_BLUE,
+        padding=(1, 2),
+        title="[bold]🏌️ Welcome to Golf 🏌️[/bold]",
+        title_align="center",
+    )
+
+    console.print(panel)
+
+
+def create_command_header(title: str, subtitle: str = "", console: Console | None = None) -> None:
+    """Create a styled command header."""
+    if console is None:
+        console = Console()
+
+    header = Text()
+    header.append("🏌️ ", style=f"bold {GOLF_ORANGE}")
+    header.append(title, style=f"bold {GOLF_BLUE}")
+
+    if subtitle:
+        header.append(f" → {subtitle}", style=f"bold {GOLF_ORANGE}")
+
+    # Create a stylish panel for the header
+    panel = Panel(
+        Align.center(header),
+        border_style=GOLF_BLUE,
+        padding=(0, 2),
+    )
+
+    console.print(panel)
+
+
+def create_success_message(message: str, console: Console | None = None) -> None:
+    """Create a styled success message."""
+    if console is None:
+        console = Console()
+
+    success_content = Text()
+    success_content.append("🎉 ", style=f"bold {GOLF_ORANGE}")
+    success_content.append(f"{STATUS_ICONS['success']} {message}", style=f"bold {GOLF_GREEN}")
+    success_content.append(" 🎉", style=f"bold {GOLF_ORANGE}")
+
+    success_panel = Panel(
+        Align.center(success_content),
+        border_style=GOLF_GREEN,
+        padding=(0, 2),
+        title="[bold green]SUCCESS[/bold green]",
+        title_align="center",
+    )
+    console.print(success_panel)
+
+
+def create_info_panel(title: str, content: str, console: Console | None = None) -> None:
+    """Create a styled info panel."""
+    if console is None:
+        console = Console()
+
+    # Add some visual flair to the content
+    styled_content = Text()
+    for line in content.split("\n"):
+        if line.strip():
+            styled_content.append("▶ ", style=f"bold {GOLF_ORANGE}")
+            styled_content.append(line, style="bold white")
+            styled_content.append("\n")
+
+    panel = Panel(
+        styled_content,
+        title=f"[bold {GOLF_BLUE}]🔧 {title} 🔧[/bold {GOLF_BLUE}]",
+        border_style=GOLF_BLUE,
+        padding=(1, 2),
+    )
+    console.print(panel)
+
+
+def get_status_text(status: str, message: str, style: str = "") -> Text:
+    """Get formatted status text with icon."""
+    icon = STATUS_ICONS.get(status, "•")
+    text = Text()
+
+    if status == "success":
+        text.append("🎉 ", style=f"bold {GOLF_ORANGE}")
+        text.append(f"{icon} {message}", style=f"bold {GOLF_GREEN}")
+    elif status == "error":
+        text.append("💥 ", style=f"bold {GOLF_ORANGE}")
+        text.append(f"{icon} {message}", style="bold red")
+    elif status == "warning":
+        text.append("⚡ ", style=f"bold {GOLF_ORANGE}")
+        text.append(f"{icon} {message}", style=f"bold {GOLF_ORANGE}")
+    elif status in ["building", "generating", "packaging", "platform"]:
+        text.append("🔥 ", style=f"bold {GOLF_ORANGE}")
+        text.append(f"{icon} {message}", style=f"bold {GOLF_BLUE}")
+    else:
+        text.append("💡 ", style=f"bold {GOLF_ORANGE}")
+        text.append(f"{icon} {message}", style=f"bold {GOLF_BLUE}")
+
+    return text
+
+
+def create_build_header(project_name: str, environment: str, console: Console) -> None:
+    """Create a styled build process header."""
+    title = Text()
+    title.append("🔨 Building ", style=f"bold {GOLF_ORANGE}")
+    title.append(project_name, style=f"bold {GOLF_BLUE}")
+    title.append(f" ({environment} environment)", style=f"bold {GOLF_GREEN}")
+
+    # Create a flashy build panel
+    panel = Panel(
+        Align.center(title),
+        border_style=GOLF_ORANGE,
+        padding=(0, 2),
+        title="[bold]🚧 BUILD IN PROGRESS 🚧[/bold]",
+        title_align="center",
+    )
+
+    console.print(panel)

golf/cli/main.py

@@ -6,9 +6,9 @@ from pathlib import Path
 
 import typer
 from rich.console import Console
-from rich.panel import Panel
 
 from golf import __version__
+from golf.cli.branding import create_welcome_banner, create_command_header
 from golf.core.config import find_project_root, load_settings
 from golf.core.telemetry import (
     is_telemetry_enabled,
@@ -35,7 +35,7 @@ atexit.register(shutdown)
 def _version_callback(value: bool) -> None:
     """Print version and exit if --version flag is used."""
     if value:
-        console.print(f"GolfMCP v{__version__}")
+        create_welcome_banner(__version__, console)
         raise typer.Exit()
 
 
@@ -49,9 +49,7 @@ def callback(
         callback=_version_callback,
         is_eager=True,
     ),
-    verbose: bool = typer.Option(
-        False, "--verbose", "-v", help="Increase verbosity of output."
-    ),
+    verbose: bool = typer.Option(False, "--verbose", "-v", help="Increase verbosity of output."),
     no_telemetry: bool = typer.Option(
         False,
         "--no-telemetry",
@@ -77,26 +75,24 @@ def callback(
     # Set telemetry preference if flag is used (permanent)
     if no_telemetry:
         set_telemetry_enabled(False, persist=True)
-        console.print(
-            "[dim]Telemetry has been disabled. You can re-enable it with: golf telemetry enable[/dim]"
-        )
+        console.print("[dim]Telemetry has been disabled. You can re-enable it with: golf telemetry enable[/dim]")
 
 
 @app.command()
 def init(
     project_name: str = typer.Argument(..., help="Name of the project to create"),
-    output_dir: Path | None = typer.Option(
-        None, "--output-dir", "-o", help="Directory to create the project in"
-    ),
-    template: str = typer.Option(
-        "basic", "--template", "-t", help="Template to use (basic or api_key)"
-    ),
+    output_dir: Path | None = typer.Option(None, "--output-dir", "-o", help="Directory to create the project in"),
 ) -> None:
     """Initialize a new GolfMCP project.
 
     Creates a new directory with the project scaffold, including
     examples for tools, resources, and prompts.
     """
+    # Show the Golf logo for project initialization
+    create_welcome_banner(__version__, console)
+    console.print()
+    create_command_header("Initialize Project", f"Creating {project_name}", console)
+
     # Import here to avoid circular imports
     from golf.commands.init import initialize_project
 
@@ -105,9 +101,7 @@ def init(
         output_dir = Path.cwd() / project_name
 
     # Execute the initialization command (it handles its own tracking)
-    initialize_project(
-        project_name=project_name, output_dir=output_dir, template=template
-    )
+    initialize_project(project_name=project_name, output_dir=output_dir)
 
 
 # Create a build group with subcommands
@@ -117,9 +111,7 @@ app.add_typer(build_app, name="build")
 
 @build_app.command("dev")
 def build_dev(
-    output_dir: str | None = typer.Option(
-        None, "--output-dir", "-o", help="Directory to output the built project"
-    ),
+    output_dir: str | None = typer.Option(None, "--output-dir", "-o", help="Directory to output the built project"),
 ) -> None:
     """Build a development version with app environment variables copied.
 
@@ -155,9 +147,7 @@ def build_dev(
         # Build the project with environment variables copied
         from golf.commands.build import build_project
 
-        build_project(
-            project_root, settings, output_dir, build_env="dev", copy_env=True
-        )
+        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 as e:
@@ -173,9 +163,7 @@ def build_dev(
 
 @build_app.command("prod")
 def build_prod(
-    output_dir: str | None = typer.Option(
-        None, "--output-dir", "-o", help="Directory to output the built project"
-    ),
+    output_dir: str | None = typer.Option(None, "--output-dir", "-o", help="Directory to output the built project"),
 ) -> None:
     """Build a production version for deployment.
 
@@ -214,9 +202,7 @@ def build_prod(
         # Build the project without copying environment variables
         from golf.commands.build import build_project
 
-        build_project(
-            project_root, settings, output_dir, build_env="prod", copy_env=False
-        )
+        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 as e:
@@ -232,18 +218,10 @@ def build_prod(
 
 @app.command()
 def run(
-    dist_dir: str | None = typer.Option(
-        None, "--dist-dir", "-d", help="Directory containing the built server"
-    ),
-    host: str | None = typer.Option(
-        None, "--host", "-h", help="Host to bind to (overrides settings)"
-    ),
-    port: int | None = typer.Option(
-        None, "--port", "-p", help="Port to bind to (overrides settings)"
-    ),
-    build_first: bool = typer.Option(
-        True, "--build/--no-build", help="Build the project before running"
-    ),
+    dist_dir: str | None = typer.Option(None, "--dist-dir", "-d", help="Directory containing the built server"),
+    host: str | None = typer.Option(None, "--host", "-h", help="Host to bind to (overrides settings)"),
+    port: int | None = typer.Option(None, "--port", "-p", help="Port to bind to (overrides settings)"),
+    build_first: bool = typer.Option(True, "--build/--no-build", help="Build the project before running"),
 ) -> None:
     """Run the built FastMCP server.
 
@@ -277,9 +255,7 @@ def run(
     # Check if dist directory exists
     if not dist_dir.exists():
         if build_first:
-            console.print(
-                f"[yellow]Dist directory {dist_dir} not found. Building first...[/yellow]"
-            )
+            console.print(f"[yellow]Dist directory {dist_dir} not found. Building first...[/yellow]")
             try:
                 # Build the project
                 from golf.commands.build import build_project
@@ -296,12 +272,8 @@ def run(
                 )
                 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."
-            )
+            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",
                 {
@@ -355,7 +327,7 @@ def run(
                 {
                     "success": False,
                     "error_type": "UnexpectedExit",
-                    "error_message": f"Server process exited unexpectedly with code {return_code}",
+                    "error_message": (f"Server process exited unexpectedly with code {return_code}"),
                     "exit_code": return_code,
                     "operation": "server_process_execution",
                     "context": "Server process terminated with unexpected exit code",
@@ -384,36 +356,23 @@ def telemetry(
     """Manage telemetry settings."""
     if action.lower() == "enable":
         set_telemetry_enabled(True, persist=True)
-        console.print(
-            "[green]✓[/green] Telemetry enabled. Thank you for helping improve Golf!"
-        )
+        console.print("[green]✓[/green] Telemetry enabled. Thank you for helping improve Golf!")
     elif action.lower() == "disable":
         set_telemetry_enabled(False, persist=True)
-        console.print(
-            "[yellow]Telemetry disabled.[/yellow] You can re-enable it anytime with: golf telemetry enable"
-        )
+        console.print("[yellow]Telemetry disabled.[/yellow] You can re-enable it anytime with: golf telemetry enable")
     else:
-        console.print(
-            f"[red]Unknown action '{action}'. Use 'enable' or 'disable'.[/red]"
-        )
+        console.print(f"[red]Unknown action '{action}'. Use 'enable' or 'disable'.[/red]")
         raise typer.Exit(code=1)
 
 
 if __name__ == "__main__":
     # Show welcome banner when run directly
-    console.print(
-        Panel.fit(
-            f"[bold green]GolfMCP[/bold green] v{__version__}\n"
-            "[dim]A Pythonic framework for building MCP servers[/dim]",
-            border_style="green",
-        )
-    )
+    create_welcome_banner(__version__, console)
 
     # Add telemetry notice if enabled
     if is_telemetry_enabled():
         console.print(
-            "[dim]📊 Anonymous usage data is collected to improve Golf. "
-            "Disable with: golf telemetry disable[/dim]\n"
+            "[dim]📊 Anonymous usage data is collected to improve Golf. Disable with: golf telemetry disable[/dim]\n"
         )
 
     # Run the CLI app

golf/commands/__init__.py

@@ -1,3 +1,5 @@
 """GolfMCP command implementations."""
 
 from golf.commands import build, init, run
+
+__all__ = ["build", "init", "run"]

golf/commands/build.py

@@ -32,16 +32,13 @@ def build_project(
         copy_env: Whether to copy environment variables to the built app
     """
     # Call the centralized build function from core.builder
-    core_build_project(
-        project_path, settings, output_dir, build_env=build_env, copy_env=copy_env
-    )
+    core_build_project(project_path, settings, output_dir, build_env=build_env, copy_env=copy_env)
 
 
-# Add a main section to run the build_project function when this module is executed directly
+# Add a main section to run the build_project function when this module is
+# executed directly
 if __name__ == "__main__":
-    parser = argparse.ArgumentParser(
-        description="Build a standalone FastMCP application"
-    )
+    parser = argparse.ArgumentParser(description="Build a standalone FastMCP application")
     parser.add_argument(
         "--project-path",
         "-p",