mcp-code-indexer 4.0.1__py3-none-any.whl → 4.1.0__py3-none-any.whl

mcp_code_indexer/middleware/auth.py

@@ -5,12 +5,12 @@ Provides Bearer token authentication for HTTP transport.
 """
 
 import logging
-from typing import Optional
+from typing import Any, Awaitable, Callable, List, Optional
 
 try:
     from fastapi import HTTPException, Request
-    from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
     from starlette.middleware.base import BaseHTTPMiddleware
+    from starlette.responses import Response
 except ImportError as e:
     raise ImportError(
         "HTTP middleware dependencies not installed. "
@@ -24,20 +24,20 @@ logger = logging.getLogger(__name__)
 class HTTPAuthMiddleware(BaseHTTPMiddleware):
     """
     HTTP authentication middleware using Bearer tokens.
-    
+
     Validates Bearer tokens for protected endpoints while allowing
     public endpoints to pass through.
     """
-    
+
     def __init__(
         self,
-        app,
+        app: Any,
         auth_token: Optional[str] = None,
-        public_paths: Optional[list] = None,
-    ):
+        public_paths: Optional[List[str]] = None,
+    ) -> None:
         """
         Initialize HTTP authentication middleware.
-        
+
         Args:
             app: FastAPI application instance
             auth_token: Expected Bearer token for authentication
@@ -47,36 +47,38 @@ class HTTPAuthMiddleware(BaseHTTPMiddleware):
         self.auth_token = auth_token
         self.public_paths = public_paths or ["/health", "/docs", "/openapi.json"]
         self.logger = logger.getChild("http_auth")
-        
+
         # Only enable auth if token is provided
         self.auth_enabled = auth_token is not None
-        
+
         if self.auth_enabled:
             self.logger.info("HTTP authentication enabled")
         else:
             self.logger.info("HTTP authentication disabled")
-    
-    async def dispatch(self, request: Request, call_next):
+
+    async def dispatch(
+        self, request: Request, call_next: Callable[[Request], Awaitable[Response]]
+    ) -> Response:
         """
         Process HTTP request and validate authentication.
-        
+
         Args:
             request: FastAPI request object
             call_next: Next middleware in chain
-            
+
         Returns:
             HTTP response
-            
+
         Raises:
             HTTPException: If authentication fails
         """
         # Skip authentication for public paths
         if not self.auth_enabled or request.url.path in self.public_paths:
             return await call_next(request)
-        
+
         # Extract Authorization header
         auth_header = request.headers.get("authorization")
-        
+
         if not auth_header:
             self.logger.warning(
                 f"Missing authorization header for {request.url.path}",
@@ -93,7 +95,7 @@ class HTTPAuthMiddleware(BaseHTTPMiddleware):
                 detail="Authorization header required",
                 headers={"WWW-Authenticate": "Bearer"},
             )
-        
+
         # Validate Bearer token format
         if not auth_header.startswith("Bearer "):
             self.logger.warning(
@@ -101,7 +103,9 @@ class HTTPAuthMiddleware(BaseHTTPMiddleware):
                 extra={
                     "structured_data": {
                         "path": request.url.path,
-                        "auth_format": auth_header.split(" ")[0] if " " in auth_header else auth_header,
+                        "auth_format": auth_header.split(" ")[0]
+                        if " " in auth_header
+                        else auth_header,
                         "client_ip": self._get_client_ip(request),
                     }
                 },
@@ -111,10 +115,10 @@ class HTTPAuthMiddleware(BaseHTTPMiddleware):
                 detail="Invalid authorization format. Use: Bearer <token>",
                 headers={"WWW-Authenticate": "Bearer"},
             )
-        
+
         # Extract and validate token
         token = auth_header[7:]  # Remove "Bearer " prefix
-        
+
         if token != self.auth_token:
             self.logger.warning(
                 f"Invalid token for {request.url.path}",
@@ -131,7 +135,7 @@ class HTTPAuthMiddleware(BaseHTTPMiddleware):
                 detail="Invalid authentication token",
                 headers={"WWW-Authenticate": "Bearer"},
             )
-        
+
         # Token is valid, proceed with request
         self.logger.debug(
             f"Authentication successful for {request.url.path}",
@@ -142,87 +146,87 @@ class HTTPAuthMiddleware(BaseHTTPMiddleware):
                 }
             },
         )
-        
+
         return await call_next(request)
-    
+
     def _get_client_ip(self, request: Request) -> str:
         """Extract client IP address from request."""
         # Check for forwarded headers
         forwarded_for = request.headers.get("x-forwarded-for")
         if forwarded_for:
             return forwarded_for.split(",")[0].strip()
-            
+
         real_ip = request.headers.get("x-real-ip")
         if real_ip:
             return real_ip
-            
+
         # Fall back to direct client IP
-        if hasattr(request.client, "host"):
+        if request.client and hasattr(request.client, "host"):
             return request.client.host
-            
+
         return "unknown"
 
 
 class TokenValidator:
     """
     Utility class for token validation logic.
-    
+
     Provides methods for validating different token formats
     and managing token-based authentication.
     """
-    
+
     @staticmethod
     def validate_bearer_token(token: str, expected_token: str) -> bool:
         """
         Validate Bearer token against expected value.
-        
+
         Args:
             token: Token to validate
             expected_token: Expected token value
-            
+
         Returns:
             True if token is valid, False otherwise
         """
         if not token or not expected_token:
             return False
-            
+
         # Simple string comparison for now
         # In production, consider using constant-time comparison
         return token == expected_token
-    
+
     @staticmethod
     def generate_token(length: int = 32) -> str:
         """
         Generate a random token for authentication.
-        
+
         Args:
             length: Length of token to generate
-            
+
         Returns:
             Random token string
         """
         import secrets
         import string
-        
+
         alphabet = string.ascii_letters + string.digits
-        return ''.join(secrets.choice(alphabet) for _ in range(length))
-    
+        return "".join(secrets.choice(alphabet) for _ in range(length))
+
     @staticmethod
     def mask_token(token: str, visible_chars: int = 8) -> str:
         """
         Mask token for logging purposes.
-        
+
         Args:
             token: Token to mask
             visible_chars: Number of characters to show
-            
+
         Returns:
             Masked token string
         """
         if not token:
             return ""
-            
+
         if len(token) <= visible_chars:
             return "*" * len(token)
-            
+
         return token[:visible_chars] + "..." + "*" * (len(token) - visible_chars)

mcp_code_indexer/middleware/error_middleware.py

@@ -8,7 +8,7 @@ error handling across all MCP tool implementations.
 import asyncio
 import functools
 import time
-from typing import Any, Callable, Dict, List
+from typing import Any, Callable, Dict, List, Optional
 
 import aiosqlite
 from mcp import types
@@ -16,8 +16,8 @@ from mcp import types
 from mcp_code_indexer.error_handler import ErrorHandler
 from mcp_code_indexer.logging_config import (
     get_logger,
-    log_tool_usage,
     log_performance_metrics,
+    log_tool_usage,
 )
 
 logger = get_logger(__name__)
@@ -30,7 +30,7 @@ class ToolMiddleware:
         """Initialize middleware with error handler."""
         self.error_handler = error_handler
 
-    def wrap_tool_handler(self, tool_name: str):
+    def wrap_tool_handler(self, tool_name: str) -> Callable[[Callable], Callable]:
         """
         Decorator to wrap tool handlers with error handling and logging.
 
@@ -84,7 +84,7 @@ class ToolMiddleware:
                         arguments_count=len(arguments),
                     )
 
-                    return result
+                    return result  # type: ignore
 
                 except Exception as e:
                     duration = time.time() - start_time
@@ -135,8 +135,8 @@ class ToolMiddleware:
         return decorator
 
     def validate_tool_arguments(
-        self, required_fields: List[str], optional_fields: List[str] = None
-    ):
+        self, required_fields: List[str], optional_fields: Optional[List[str]] = None
+    ) -> Callable[[Callable], Callable]:
         """
         Decorator to validate tool arguments.
 
@@ -220,7 +220,7 @@ class AsyncTaskManager:
         self.error_handler = error_handler
         self._tasks: List[asyncio.Task] = []
 
-    def create_task(self, coro, name: str = None) -> asyncio.Task:
+    def create_task(self, coro: Any, name: Optional[str] = None) -> asyncio.Task:
         """
         Create a managed async task.
 
@@ -257,7 +257,7 @@ class AsyncTaskManager:
             if task in self._tasks:
                 self._tasks.remove(task)
 
-    async def wait_for_all(self, timeout: float = None) -> None:
+    async def wait_for_all(self, timeout: Optional[float] = None) -> None:
         """
         Wait for all managed tasks to complete.
 
@@ -309,12 +309,12 @@ def create_tool_middleware(error_handler: ErrorHandler) -> ToolMiddleware:
 # Convenience decorators for common patterns
 
 
-def require_fields(*required_fields):
+def require_fields(*required_fields: str) -> Callable[[Callable], Callable]:
     """Decorator that requires specific fields in arguments."""
 
-    def decorator(func):
+    def decorator(func: Callable) -> Callable:
         @functools.wraps(func)
-        async def wrapper(self, arguments: Dict[str, Any]):
+        async def wrapper(self: Any, arguments: Dict[str, Any]) -> Any:
             from ..error_handler import ValidationError
 
             missing = [field for field in required_fields if field not in arguments]
@@ -328,11 +328,11 @@ def require_fields(*required_fields):
     return decorator
 
 
-def handle_file_operations(func):
+def handle_file_operations(func: Callable) -> Callable:
     """Decorator for file operation error handling."""
 
     @functools.wraps(func)
-    async def wrapper(*args, **kwargs):
+    async def wrapper(*args: Any, **kwargs: Any) -> Any:
         try:
             return await func(*args, **kwargs)
         except (FileNotFoundError, PermissionError, OSError) as e:
@@ -343,11 +343,11 @@ def handle_file_operations(func):
     return wrapper
 
 
-def handle_database_operations(func):
+def handle_database_operations(func: Callable) -> Callable:
     """Decorator for database operation error handling."""
 
     @functools.wraps(func)
-    async def wrapper(*args, **kwargs):
+    async def wrapper(*args: Any, **kwargs: Any) -> Any:
         try:
             return await func(*args, **kwargs)
         except Exception as e:

mcp_code_indexer/middleware/logging.py

@@ -4,10 +4,9 @@ HTTP logging middleware for MCP Code Indexer.
 Provides request/response logging and monitoring for HTTP transport.
 """
 
-import json
 import logging
 import time
-from typing import Any, Dict, Optional
+from typing import Any, Awaitable, Callable, Dict, List
 
 try:
     from fastapi import Request, Response
@@ -26,15 +25,15 @@ logger = logging.getLogger(__name__)
 class HTTPLoggingMiddleware(BaseHTTPMiddleware):
     """
     HTTP request/response logging middleware.
-    
+
     Logs HTTP requests and responses with performance metrics
     and structured data for monitoring.
     """
-    
+
     def __init__(self, app: Any, log_level: str = "INFO"):
         """
         Initialize HTTP logging middleware.
-        
+
         Args:
             app: FastAPI application instance
             log_level: Logging level for HTTP requests
@@ -43,25 +42,27 @@ class HTTPLoggingMiddleware(BaseHTTPMiddleware):
         self.log_level = getattr(logging, log_level.upper())
         self.logger = logger.getChild("http_access")
         self.logger.setLevel(self.log_level)
-        
-    async def dispatch(self, request: Request, call_next) -> Response:
+
+    async def dispatch(
+        self, request: Request, call_next: Callable[[Request], Awaitable[Response]]
+    ) -> Response:
         """
         Process HTTP request and log access information.
-        
+
         Args:
             request: FastAPI request object
             call_next: Next middleware in chain
-            
+
         Returns:
             HTTP response
         """
         start_time = time.time()
         request_id = self._generate_request_id(request)
-        
+
         # Extract client information
         client_ip = self._get_client_ip(request)
         user_agent = request.headers.get("user-agent", "")
-        
+
         # Log incoming request
         self.logger.info(
             f"HTTP {request.method} {request.url.path}",
@@ -79,17 +80,17 @@ class HTTPLoggingMiddleware(BaseHTTPMiddleware):
                 }
             },
         )
-        
+
         # Add request ID to request state for use in handlers
         request.state.request_id = request_id
-        
+
         try:
             # Process request
             response = await call_next(request)
-            
+
             # Calculate processing time
             process_time = time.time() - start_time
-            
+
             # Log response
             self._log_response(
                 request_id=request_id,
@@ -99,17 +100,17 @@ class HTTPLoggingMiddleware(BaseHTTPMiddleware):
                 process_time=process_time,
                 response=response,
             )
-            
+
             # Add performance headers
             response.headers["X-Process-Time"] = str(process_time)
             response.headers["X-Request-ID"] = request_id
-            
+
             return response
-            
+
         except Exception as e:
             # Log error
             process_time = time.time() - start_time
-            
+
             self.logger.error(
                 f"HTTP {request.method} {request.url.path} - ERROR",
                 extra={
@@ -124,31 +125,32 @@ class HTTPLoggingMiddleware(BaseHTTPMiddleware):
                     }
                 },
             )
-            
+
             raise
-    
+
     def _generate_request_id(self, request: Request) -> str:
         """Generate unique request ID."""
         import uuid
+
         return str(uuid.uuid4())[:8]
-    
+
     def _get_client_ip(self, request: Request) -> str:
         """Extract client IP address from request."""
         # Check for forwarded headers
         forwarded_for = request.headers.get("x-forwarded-for")
         if forwarded_for:
             return forwarded_for.split(",")[0].strip()
-            
+
         real_ip = request.headers.get("x-real-ip")
         if real_ip:
             return real_ip
-            
+
         # Fall back to direct client IP
-        if hasattr(request.client, "host"):
+        if request.client and hasattr(request.client, "host"):
             return request.client.host
-            
+
         return "unknown"
-    
+
     def _log_response(
         self,
         request_id: str,
@@ -166,14 +168,14 @@ class HTTPLoggingMiddleware(BaseHTTPMiddleware):
             log_level = logging.WARNING
         else:
             log_level = self.log_level
-        
+
         # Extract response information
         content_length = response.headers.get("content-length")
         content_type = response.headers.get("content-type")
-        
+
         # Check if this is a streaming response
         is_streaming = isinstance(response, StreamingResponse)
-        
+
         self.logger.log(
             log_level,
             f"HTTP {method} {path} - {status_code}",
@@ -192,7 +194,7 @@ class HTTPLoggingMiddleware(BaseHTTPMiddleware):
                 }
             },
         )
-    
+
     def _categorize_performance(self, process_time: float) -> str:
         """Categorize request performance."""
         if process_time < 0.1:
@@ -208,18 +210,18 @@ class HTTPLoggingMiddleware(BaseHTTPMiddleware):
 class HTTPMetricsCollector:
     """
     Collect HTTP metrics for monitoring.
-    
+
     Tracks request counts, response times, and error rates.
     """
-    
-    def __init__(self):
+
+    def __init__(self) -> None:
         """Initialize metrics collector."""
         self.request_count = 0
         self.error_count = 0
         self.total_response_time = 0.0
-        self.response_times = []
+        self.response_times: List[float] = []
         self.max_response_times = 1000  # Keep last 1000 response times
-        
+
     def record_request(
         self,
         method: str,
@@ -230,16 +232,16 @@ class HTTPMetricsCollector:
         """Record HTTP request metrics."""
         self.request_count += 1
         self.total_response_time += response_time
-        
+
         # Track error rates
         if status_code >= 400:
             self.error_count += 1
-            
+
         # Track response times
         self.response_times.append(response_time)
         if len(self.response_times) > self.max_response_times:
             self.response_times.pop(0)
-    
+
     def get_metrics(self) -> Dict[str, Any]:
         """Get current metrics summary."""
         if not self.request_count:
@@ -251,12 +253,12 @@ class HTTPMetricsCollector:
                 "p95_response_time": 0.0,
                 "p99_response_time": 0.0,
             }
-        
+
         # Calculate percentiles
         sorted_times = sorted(self.response_times)
         p95_index = int(0.95 * len(sorted_times))
         p99_index = int(0.99 * len(sorted_times))
-        
+
         return {
             "request_count": self.request_count,
             "error_count": self.error_count,
@@ -265,7 +267,7 @@ class HTTPMetricsCollector:
             "p95_response_time": sorted_times[p95_index] if sorted_times else 0.0,
             "p99_response_time": sorted_times[p99_index] if sorted_times else 0.0,
         }
-    
+
     def reset_metrics(self) -> None:
         """Reset all metrics."""
         self.request_count = 0