docker-compose.yml

@@ -1,12 +1,12 @@
 services:
   geoguessr-mcp:
     # Option 1: Build locally (for development)
-    # build:
+    build:
-    #   context: .
+      context: .
-    #   dockerfile: Dockerfile
+      dockerfile: Dockerfile
 
     # Option 2: Use pre-built image from Docker Hub (recommended)
-    image: nyxiumyuuki/geoguessr-mcp:latest
+    # image: nyxiumyuuki/geoguessr-mcp:latest
 
     container_name: geoguessr-mcp-server
     restart: unless-stopped

src/geoguessr_mcp/auth/multi_user_session.py

@@ -64,9 +64,7 @@ class MultiUserSessionManager:
 
         return context
 
-    async def login_user(
+    async def login_user(self, api_key: str, email: str, password: str) -> tuple[str, UserSession]:
-        self, api_key: str, email: str, password: str
-    ) -> tuple[str, UserSession]:
         """
         Login a specific user (API key) to their GeoGuessr account.
 
@@ -90,9 +88,7 @@ class MultiUserSessionManager:
         # Perform login
         session_token, session = await manager.login(email, password)
 
-        logger.info(
+        logger.info(f"User {session.username} logged in successfully for API key {api_key[:8]}...")
-            f"User {session.username} logged in successfully for API key {api_key[:8]}..."
-        )
 
         return session_token, session
 

src/geoguessr_mcp/config.py

@@ -37,9 +37,7 @@ class Settings:
     MCP_AUTH_ENABLED: bool = field(
         default_factory=lambda: os.getenv("MCP_AUTH_ENABLED", "false").lower() == "true"
     )
-    MCP_API_KEYS: Optional[str] = field(
+    MCP_API_KEYS: Optional[str] = field(default_factory=lambda: os.getenv("MCP_API_KEYS"))
-        default_factory=lambda: os.getenv("MCP_API_KEYS")
-    )
 
     # Logging Configuration
     LOG_LEVEL: str = field(default_factory=lambda: os.getenv("LOG_LEVEL", "INFO"))

src/geoguessr_mcp/main.py

@@ -9,10 +9,10 @@ import logging
 import sys
 
 from mcp.server.fastmcp import FastMCP
+from starlette.middleware.cors import CORSMiddleware
 
 from .config import settings
 from .middleware import AuthenticationMiddleware
-from .monitoring import endpoint_monitor
 from .tools import register_all_tools
 
 # Configure logging
@@ -25,8 +25,11 @@ logging.basicConfig(
 logger = logging.getLogger(__name__)
 
 
-# Create the MCP server instance
+def main():
-mcp = FastMCP(
+    """Main entry point for the server."""
+
+    # Create the MCP server instance
+    mcp = FastMCP(
         "GeoGuessr Analyzer",
         instructions="""
         MCP server for analyzing GeoGuessr game statistics and optimizing gameplay strategy.
@@ -54,33 +57,28 @@ mcp = FastMCP(
         """,
         host=settings.HOST,
         port=settings.PORT,
-)
+    )
 
-# Register all tools
+    # Register all tools
-services = register_all_tools(mcp)
+    register_all_tools(mcp)
 
-# Add authentication middleware if needed
+    # Setup authentication middleware if enabled
-if settings.MCP_AUTH_ENABLED:
+    if settings.MCP_AUTH_ENABLED:
-    logger.info("Registering authentication middleware")
+        logger.info("Setting up authentication middleware")
-    # Add middleware to the underlying ASGI app
-    mcp.app.add_middleware(AuthenticationMiddleware)
 
+        # Récupérez l'application ASGI via streamable_http_app
+        mcp_app = mcp.streamable_http_app()
 
-async def start_background_tasks():
+        # Ajoutez les middlewares
-    """Start background monitoring tasks."""
+        mcp_app.add_middleware(
-    if settings.MONITORING_ENABLED:
+            CORSMiddleware,
-        logger.info("Starting API monitoring background task...")
+            allow_origins=["*"],
-        await endpoint_monitor.start_periodic_monitoring()
+            allow_credentials=True,
+            allow_methods=["*"],
+            allow_headers=["*"],
+        )
+        mcp_app.add_middleware(AuthenticationMiddleware)
 
-
-async def stop_background_tasks():
-    """Stop background monitoring tasks."""
-    if endpoint_monitor._running:
-        await endpoint_monitor.stop_monitoring()
-
-
-def main():
-    """Main entry point for the server."""
     logger.info(
         f"Starting GeoGuessr MCP Server on {settings.HOST}:{settings.PORT} "
         f"with {settings.TRANSPORT} transport"
@@ -96,7 +94,8 @@ def main():
         logger.info("Default GeoGuessr authentication cookie configured from environment")
     else:
         logger.warning(
-            "No default GeoGuessr authentication cookie set. " "Users will need to login or provide a cookie."
+            "No default GeoGuessr authentication cookie set. "
+            "Users will need to login or provide a cookie."
         )
 
     # Run the server

src/geoguessr_mcp/middleware/auth.py

@@ -63,9 +63,9 @@ class AuthenticationMiddleware(BaseHTTPMiddleware):
                 status_code=401,
                 content={
                     "error": "Unauthorized",
-                    "message": "Missing Authorization header. Use 'Authorization: Bearer YOUR_API_KEY'"
+                    "message": "Missing Authorization header. Use 'Authorization: Bearer YOUR_API_KEY'",
                 },
-                headers={"WWW-Authenticate": "Bearer"}
+                headers={"WWW-Authenticate": "Bearer"},
             )
 
         # Parse Bearer token
@@ -76,9 +76,9 @@ class AuthenticationMiddleware(BaseHTTPMiddleware):
                 status_code=401,
                 content={
                     "error": "Unauthorized",
-                    "message": "Invalid Authorization header format. Use 'Authorization: Bearer YOUR_API_KEY'"
+                    "message": "Invalid Authorization header format. Use 'Authorization: Bearer YOUR_API_KEY'",
                 },
-                headers={"WWW-Authenticate": "Bearer"}
+                headers={"WWW-Authenticate": "Bearer"},
             )
 
         token = parts[1]
@@ -88,15 +88,14 @@ class AuthenticationMiddleware(BaseHTTPMiddleware):
             logger.warning(f"Invalid API key attempt from {request.client.host}")
             return JSONResponse(
                 status_code=403,
-                content={
+                content={"error": "Forbidden", "message": "Invalid API key"},
-                    "error": "Forbidden",
+                headers={"WWW-Authenticate": "Bearer"},
-                    "message": "Invalid API key"
-                },
-                headers={"WWW-Authenticate": "Bearer"}
             )
 
         # Authentication successful
-        logger.debug(f"Authenticated request from {request.client.host} with API key {token[:8]}...")
+        logger.debug(
+            f"Authenticated request from {request.client.host} with API key {token[:8]}..."
+        )
 
         # Get or create user context for this API key
         user_context = await multi_user_session_manager.get_user_context(token)

src/geoguessr_mcp/monitoring/schema/schema_registry.py

@@ -12,6 +12,7 @@ Classes:
 
 import json
 import logging
+import tempfile
 from datetime import UTC, datetime
 from pathlib import Path
 from typing import Any, Optional
@@ -33,7 +34,20 @@ class SchemaRegistry:
 
     def __init__(self, cache_dir: Optional[str] = None):
         self.cache_dir = Path(cache_dir or settings.SCHEMA_CACHE_DIR)
+
+        # Try to create the cache directory, fall back to temp if permission denied
+        try:
             self.cache_dir.mkdir(parents=True, exist_ok=True)
+        except (PermissionError, OSError) as e:
+            logger.warning(
+                f"Cannot create schema cache directory at {self.cache_dir}: {e}. "
+                f"Using temporary directory instead."
+            )
+            # Use a temporary directory that will be cleaned up
+            temp_dir = tempfile.mkdtemp(prefix="geoguessr_schema_")
+            self.cache_dir = Path(temp_dir)
+            logger.info(f"Using temporary schema cache directory: {self.cache_dir}")
+
         self.schemas: dict[str, EndpointSchema] = {}
         self.schema_history: dict[str, list[EndpointSchema]] = {}
         self.detector = SchemaDetector()

src/geoguessr_mcp/tools/auth_tools.py

@@ -99,9 +99,7 @@ def register_auth_tools(mcp: FastMCP, session_manager=None):
         if not user_context:
             return {"success": False, "error": "No user context available"}
 
-        success = await multi_user_session_manager.logout_user(
+        success = await multi_user_session_manager.logout_user(user_context.api_key, session_token)
-            user_context.api_key, session_token
-        )
 
         return {
             "success": success,

src/tests/unit/auth/test_multi_user_session.py

@@ -0,0 +1,93 @@
+"""Tests for MultiUserSessionManager."""
+
+import pytest
+
+from geoguessr_mcp.auth.multi_user_session import MultiUserSessionManager
+from geoguessr_mcp.auth.session import SessionManager
+
+
+class TestMultiUserSessionManager:
+    """Tests for MultiUserSessionManager class."""
+
+    @pytest.fixture
+    def manager(self):
+        """Create a fresh MultiUserSessionManager for each test."""
+        return MultiUserSessionManager()
+
+    @pytest.mark.asyncio
+    async def test_get_user_context_creates_new_manager(self, manager):
+        """Test that getting context for a new API key creates a new session manager."""
+        context = await manager.get_user_context("new_api_key")
+
+        assert context.api_key == "new_api_key"
+        assert "new_api_key" in manager._user_managers
+        assert isinstance(manager._user_managers["new_api_key"], SessionManager)
+
+    @pytest.mark.asyncio
+    async def test_get_user_context_reuses_existing_manager(self, manager):
+        """Test that getting context for existing API key reuses the same manager."""
+        context1 = await manager.get_user_context("existing_key")
+        context2 = await manager.get_user_context("existing_key")
+
+        # Should use the same manager instance
+        assert manager._user_managers["existing_key"] is manager._user_managers["existing_key"]
+        assert len(manager._user_managers) == 1
+
+    @pytest.mark.asyncio
+    async def test_multiple_api_keys_get_separate_managers(self, manager):
+        """Test that different API keys get separate session managers."""
+        context1 = await manager.get_user_context("key1")
+        context2 = await manager.get_user_context("key2")
+        context3 = await manager.get_user_context("key3")
+
+        assert len(manager._user_managers) == 3
+        assert manager._user_managers["key1"] is not manager._user_managers["key2"]
+        assert manager._user_managers["key2"] is not manager._user_managers["key3"]
+
+    @pytest.mark.asyncio
+    async def test_get_auth_status_not_authenticated(self, manager):
+        """Test getting auth status for unauthenticated user."""
+        status = await manager.get_auth_status("test_key")
+
+        assert not status["authenticated"]
+        assert status["user_id"] is None
+        assert status["username"] is None
+        assert "test_key" in status["api_key"] or "***" in status["api_key"]
+
+    @pytest.mark.asyncio
+    async def test_get_session_for_api_key_none_when_not_logged_in(self, manager):
+        """Test that get_session_for_api_key returns None for non-existent key."""
+        session = await manager.get_session_for_api_key("nonexistent_key")
+        assert session is None
+
+    @pytest.mark.asyncio
+    async def test_login_user_creates_manager_if_not_exists(self, manager):
+        """Test that login_user creates a manager if it doesn't exist."""
+        # This test requires mocking the HTTP client for GeoGuessr API
+        # We'll mark it as a placeholder for now
+        pytest.skip("Requires mocking GeoGuessr API")
+
+    @pytest.mark.asyncio
+    async def test_logout_user_returns_false_for_nonexistent_key(self, manager):
+        """Test that logout_user returns False for non-existent API key."""
+        result = await manager.logout_user("nonexistent_key", "fake_session_token")
+        assert result is False
+
+    @pytest.mark.asyncio
+    async def test_set_user_cookie_validates_cookie(self, manager):
+        """Test that set_user_cookie validates the cookie."""
+        # Invalid cookie should return False
+        result = await manager.set_user_cookie("test_key", "invalid_cookie")
+        assert result is False
+
+    @pytest.mark.asyncio
+    async def test_context_isolation_between_users(self, manager):
+        """Test that contexts are properly isolated between different users."""
+        context_alice = await manager.get_user_context("alice_key")
+        context_bob = await manager.get_user_context("bob_key")
+
+        # Contexts should be different
+        assert context_alice.api_key != context_bob.api_key
+
+        # Should have separate session managers
+        assert manager._user_managers["alice_key"] is not manager._user_managers["bob_key"]

src/tests/unit/auth/test_request_context.py

@@ -0,0 +1,73 @@
+"""Tests for request context utilities."""
+
+import pytest
+
+from geoguessr_mcp.auth.request_context import (
+    get_current_user_context,
+    require_user_context,
+    set_current_user_context,
+)
+from geoguessr_mcp.auth.user_context import UserContext
+
+
+class TestRequestContext:
+    """Tests for request context utilities."""
+
+    def test_get_current_user_context_returns_none_initially(self):
+        """Test that get_current_user_context returns None when not set."""
+        # Note: This might fail if previous tests didn't clean up
+        # In a real scenario, each test would have isolated context
+        context = get_current_user_context()
+        # Context might be None or from previous test
+        assert context is None or isinstance(context, UserContext)
+
+    def test_set_and_get_current_user_context(self):
+        """Test setting and getting current user context."""
+        test_context = UserContext(api_key="test_key_123")
+
+        set_current_user_context(test_context)
+        retrieved_context = get_current_user_context()
+
+        assert retrieved_context is not None
+        assert retrieved_context.api_key == "test_key_123"
+
+    def test_require_user_context_raises_when_not_set(self):
+        """Test that require_user_context raises RuntimeError when context not set."""
+        # Clear any existing context
+        set_current_user_context(None)
+
+        with pytest.raises(RuntimeError, match="No user context available"):
+            require_user_context()
+
+    def test_require_user_context_returns_context_when_set(self):
+        """Test that require_user_context returns context when it's set."""
+        test_context = UserContext(api_key="test_key_456")
+
+        set_current_user_context(test_context)
+        retrieved_context = require_user_context()
+
+        assert retrieved_context is not None
+        assert retrieved_context.api_key == "test_key_456"
+
+    def test_context_can_be_updated(self):
+        """Test that context can be updated by setting a new one."""
+        context1 = UserContext(api_key="key1")
+        context2 = UserContext(api_key="key2")
+
+        set_current_user_context(context1)
+        assert get_current_user_context().api_key == "key1"
+
+        set_current_user_context(context2)
+        assert get_current_user_context().api_key == "key2"
+
+    def test_context_can_be_cleared(self):
+        """Test that context can be cleared by setting to None."""
+        test_context = UserContext(api_key="test_key")
+
+        set_current_user_context(test_context)
+        assert get_current_user_context() is not None
+
+        set_current_user_context(None)
+        context = get_current_user_context()
+        # After clearing, should be None
+        assert context is None

src/tests/unit/auth/test_user_context.py

@@ -0,0 +1,95 @@
+"""Tests for UserContext class."""
+
+import pytest
+
+from geoguessr_mcp.auth.session import UserSession
+from geoguessr_mcp.auth.user_context import UserContext
+from datetime import datetime, timedelta, UTC
+
+
+class TestUserContext:
+    """Tests for UserContext class."""
+
+    def test_user_context_without_session(self):
+        """Test user context without a GeoGuessr session."""
+        context = UserContext(api_key="test_key_123")
+
+        assert context.api_key == "test_key_123"
+        assert context.session is None
+        assert not context.is_authenticated
+        assert context.ncfa_cookie is None
+        assert "anonymous_" in context.user_id
+        assert "User-" in context.username
+
+    def test_user_context_with_session(self):
+        """Test user context with a GeoGuessr session."""
+        session = UserSession(
+            ncfa_cookie="test_cookie",
+            user_id="user123",
+            username="testuser",
+            email="test@example.com",
+            expires_at=datetime.now(UTC) + timedelta(days=1),
+        )
+
+        context = UserContext(api_key="test_key_123", session=session)
+
+        assert context.api_key == "test_key_123"
+        assert context.session == session
+        assert context.is_authenticated
+        assert context.ncfa_cookie == "test_cookie"
+        assert context.user_id == "user123"
+        assert context.username == "testuser"
+
+    def test_user_context_with_expired_session(self):
+        """Test user context with an expired session."""
+        session = UserSession(
+            ncfa_cookie="test_cookie",
+            user_id="user123",
+            username="testuser",
+            email="test@example.com",
+            expires_at=datetime.now(UTC) - timedelta(days=1),  # Expired
+        )
+
+        context = UserContext(api_key="test_key_123", session=session)
+
+        # Session is present but not valid
+        assert context.session == session
+        assert not context.is_authenticated  # Expired session = not authenticated
+
+    def test_user_context_repr(self):
+        """Test string representation of user context."""
+        context = UserContext(api_key="test_key_123")
+        repr_str = repr(context)
+
+        assert "UserContext" in repr_str
+        assert "not authenticated" in repr_str
+
+        session = UserSession(
+            ncfa_cookie="test_cookie",
+            user_id="user123",
+            username="testuser",
+            email="test@example.com",
+        )
+        context_with_session = UserContext(api_key="test_key_123", session=session)
+        repr_with_session = repr(context_with_session)
+
+        assert "authenticated" in repr_with_session
+        assert "user123" in repr_with_session
+
+    def test_user_context_consistent_ids(self):
+        """Test that user IDs are consistent for the same API key."""
+        context1 = UserContext(api_key="same_key")
+        context2 = UserContext(api_key="same_key")
+
+        # Same API key should produce same anonymous user ID
+        assert context1.user_id == context2.user_id
+        assert context1.username == context2.username
+
+    def test_user_context_different_ids_for_different_keys(self):
+        """Test that different API keys produce different anonymous user IDs."""
+        context1 = UserContext(api_key="key1")
+        context2 = UserContext(api_key="key2")
+
+        # Different API keys should produce different anonymous user IDs
+        assert context1.user_id != context2.user_id
+        assert context1.username != context2.username