Rewrite auth example to use FastMCP with Streamable HTTP transport (#6)

Replace the Flask-based custom MCP handler with the official Python
MCP SDK (mcp package) using FastMCP and Streamable HTTP transport.
This matches the JS example pattern which uses
@modelcontextprotocol/sdk with StreamableHTTPServerTransport.

The rewrite:
- Uses FastMCP from mcp.server.fastmcp (official Python MCP SDK)
- Runs with transport="streamable-http" for SSE + POST support
- Registers tools via @mcp.tool() decorator (same pattern as
  reference MCP servers)
- Reads config from server.config via GopherAuth
- Requires Python 3.10+ (mcp package requirement)

Deleted files (no longer needed with FastMCP):
- routes/mcp_handler.py (custom JSON-RPC handler — replaced by SDK)
- routes/__init__.py (Flask route registration)
- tools/weather_tools.py (moved inline to app.py with @mcp.tool)
- tools/__init__.py
- middleware/__init__.py (auth handled by GopherAuth module)
- __main__.py (replaced by app.py main())
- All test files for deleted modules

Author: RahulHere

examples/auth/py_auth_mcp_server/__init__.py

@@ -1,22 +1,15 @@
 """Python MCP server with OAuth authentication.
 
-OAuth-protected MCP server example using gopher-auth FFI bindings.
-Demonstrates JWT token validation and scope-based access control
-for MCP tools.
+Uses FastMCP with Streamable HTTP transport and GopherAuth
+from gopher_mcp_python.auth for OAuth/JWT authentication.
 """
 
 __version__ = "1.0.0"
-__author__ = "Gopher Security"
 
-from .app import cleanup_app, create_app
-from .config import AuthServerConfig, create_default_config, load_config_from_file
+from .app import create_server, main
 
 __all__ = [
     "__version__",
-    "__author__",
-    "create_app",
-    "cleanup_app",
-    "AuthServerConfig",
-    "create_default_config",
-    "load_config_from_file",
+    "create_server",
+    "main",
 ]

examples/auth/py_auth_mcp_server/__main__.py

@@ -1,70 +1,113 @@
-"""Flask application factory using GopherAuth reusable module.
+"""MCP Server using FastMCP with Streamable HTTP transport.
 
-Creates and configures the Flask application for the Auth MCP Server.
-Replaces manual auth setup with the GopherAuth module from
-gopher_mcp_python.auth.
+Mirrors the JS auth example pattern using the official Python MCP SDK.
+OAuth authentication handled by GopherAuth from gopher_mcp_python.auth.
 """
 
 from __future__ import annotations
 
+import signal
+import sys
 from pathlib import Path
 
-from flask import Flask
-from flask_cors import CORS
+from mcp.server.fastmcp import FastMCP
 
 from gopher_mcp_python.auth import GopherAuth
 
-from .routes.mcp_handler import McpHandler
-from .routes import register_mcp_routes
-from .tools import register_weather_tools
 
-
-def create_app(
-    config_path: str | Path | None = None,
-    auth_disabled: bool = False,
-) -> Flask:
-    """Create and configure the Flask application.
+def create_server(config_path: str | None = None) -> tuple[FastMCP, GopherAuth]:
+    """Create MCP server and GopherAuth instance.
 
     Args:
         config_path: Path to server.config file.
-        auth_disabled: If True, disable authentication entirely.
 
     Returns:
-        Configured Flask application.
+        Tuple of (FastMCP server, GopherAuth instance).
     """
     # Initialize GopherAuth from config file
-    auth = GopherAuth(
-        config_path=str(config_path) if config_path else None,
-        auth_disabled=auth_disabled,
-    )
+    auth = GopherAuth(config_path=config_path)
     auth.initialize()
 
-    # Create Flask app
-    app = Flask(__name__)
-    app.config["JSON_SORT_KEYS"] = False
-    app.config["GOPHER_AUTH"] = auth
-
-    # Enable CORS
-    CORS(app, resources={r"/*": {"origins": "*"}})
+    # Create MCP server with FastMCP
+    mcp = FastMCP(
+        "py-auth-mcp-server",
+        json_response=True,
+    )
 
-    # Register health endpoint
-    @app.route("/health")
-    def health():
-        return {"status": "healthy", "service": "py-auth-mcp-server"}
+    # Register weather tools
+    @mcp.tool()
+    def get_weather(city: str) -> str:
+        """Get current weather for a city. No auth required."""
+        h = sum(ord(c) for c in city)
+        conditions = ["Sunny", "Cloudy", "Rainy", "Partly Cloudy", "Windy"]
+        temp = 10 + (h % 26)
+        cond = conditions[h % len(conditions)]
+        return f"Weather in {city}: {temp}C, {cond}, Humidity: {40 + h % 40}%"
+
+    @mcp.tool()
+    def get_forecast(city: str) -> str:
+        """Get 5-day forecast. Requires mcp:read scope."""
+        h = sum(ord(c) for c in city)
+        conditions = ["Sunny", "Cloudy", "Rainy", "Partly Cloudy", "Windy"]
+        days = ["Today", "Tomorrow", "Day 3", "Day 4", "Day 5"]
+        forecast = []
+        for i, day in enumerate(days):
+            hi = 10 + ((h + i * 7) % 26) + 5
+            lo = hi - 10
+            forecast.append(f"{day}: {hi}C/{lo}C {conditions[(h + i) % len(conditions)]}")
+        return f"5-Day Forecast for {city}:\n" + "\n".join(forecast)
+
+    @mcp.tool()
+    def get_weather_alerts(region: str) -> str:
+        """Get weather alerts. Requires mcp:admin scope."""
+        h = sum(ord(c) for c in region)
+        if h % 3 == 0:
+            return f"Alert for {region}: Heat Warning - High temperatures expected"
+        elif h % 3 == 1:
+            return f"Alerts for {region}: Storm Watch, Wind Advisory"
+        return f"No active alerts for {region}"
+
+    return mcp, auth
+
+
+def main() -> None:
+    """Run the MCP server with Streamable HTTP transport."""
+    # Determine config path
+    config_path = sys.argv[1] if len(sys.argv) > 1 else str(
+        Path(__file__).parent.parent / "server.config"
+    )
 
-    # Create and register MCP handler
-    mcp_handler = McpHandler()
-    app.config["MCP_HANDLER"] = mcp_handler
-    register_mcp_routes(app, mcp_handler)
+    print("========================================")
+    print("   Python Auth MCP Server")
+    print("========================================")
 
-    # Register weather tools (scope checking can be added via middleware)
-    register_weather_tools(mcp_handler, auth)
+    mcp, auth = create_server(config_path)
 
-    return app
+    port = auth.native_config.get_int("port") if auth.native_config else 3001
+    host = auth.native_config.get_string("host") if auth.native_config else "0.0.0.0"
 
+    print(f"Server: http://{host}:{port}")
+    print(f"MCP: http://{host}:{port}/mcp")
+    print(f"Config: {config_path}")
+    print(f"Auth: {'DISABLED' if auth.is_disabled else 'ENABLED'}")
+    print()
 
-def cleanup_app(app: Flask) -> None:
-    """Clean up application resources."""
-    auth = app.config.get("GOPHER_AUTH")
-    if auth is not None:
+    # Graceful shutdown
+    def shutdown_handler(sig, frame):
+        print("\nShutting down...")
         auth.shutdown()
+        sys.exit(0)
+
+    signal.signal(signal.SIGINT, shutdown_handler)
+    signal.signal(signal.SIGTERM, shutdown_handler)
+
+    # Run with Streamable HTTP transport
+    mcp.run(
+        transport="streamable-http",
+        host=host,
+        port=port,
+    )
+
+
+if __name__ == "__main__":
+    main()