ccproxy-api 0.1.2__py3-none-any.whl → 0.1.3__py3-none-any.whl

ccproxy/api/app.py

@@ -5,8 +5,7 @@ from contextlib import asynccontextmanager
 from datetime import UTC, datetime
 from typing import Any
 
-from fastapi import FastAPI, HTTPException
-from fastapi.responses import JSONResponse
+from fastapi import APIRouter, FastAPI
 from fastapi.staticfiles import StaticFiles
 from structlog import get_logger
 
@@ -14,33 +13,62 @@ from ccproxy import __version__
 from ccproxy.api.middleware.cors import setup_cors_middleware
 from ccproxy.api.middleware.errors import setup_error_handlers
 from ccproxy.api.middleware.logging import AccessLogMiddleware
+from ccproxy.api.middleware.request_content_logging import (
+    RequestContentLoggingMiddleware,
+)
 from ccproxy.api.middleware.request_id import RequestIDMiddleware
 from ccproxy.api.middleware.server_header import ServerHeaderMiddleware
 from ccproxy.api.routes.claude import router as claude_router
+from ccproxy.api.routes.health import get_claude_cli_info
 from ccproxy.api.routes.health import router as health_router
+from ccproxy.api.routes.mcp import setup_mcp
 from ccproxy.api.routes.metrics import (
     dashboard_router,
     logs_router,
     prometheus_router,
 )
+from ccproxy.api.routes.permissions import router as permissions_router
 from ccproxy.api.routes.proxy import router as proxy_router
+from ccproxy.api.services.permission_service import get_permission_service
+from ccproxy.auth.credentials_adapter import CredentialsAuthManager
 from ccproxy.auth.exceptions import CredentialsNotFoundError
 from ccproxy.auth.oauth.routes import router as oauth_router
 from ccproxy.config.settings import Settings, get_settings
 from ccproxy.core.logging import setup_logging
+from ccproxy.observability import get_metrics
 from ccproxy.observability.storage.duckdb_simple import SimpleDuckDBStorage
+from ccproxy.scheduler.errors import SchedulerError
 from ccproxy.scheduler.manager import start_scheduler, stop_scheduler
+from ccproxy.services.claude_sdk_service import ClaudeSDKService
 from ccproxy.services.credentials import CredentialsManager
+from ccproxy.utils.models_provider import get_models_list
 
 
 logger = get_logger(__name__)
 
 
+# Create shared models router
+models_router = APIRouter(tags=["models"])
+
+
+@models_router.get("/v1/models", response_model=None)
+async def list_models() -> dict[str, Any]:
+    """List available models.
+
+    Returns a combined list of Anthropic models and recent OpenAI models.
+    This endpoint is shared between both SDK and proxy APIs.
+    """
+    return get_models_list()
+
+
 @asynccontextmanager
 async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
     """Application lifespan manager."""
     settings = get_settings()
 
+    # Store settings in app state for reuse in dependencies
+    app.state.settings = settings
+
     # Startup
     logger.info(
         "server_start",
@@ -77,14 +105,14 @@ async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
                     ).total_seconds()
                     / 3600
                 )
-                logger.info(
+                logger.debug(
                     "auth_token_valid",
                     expires_in_hours=hours_until_expiry,
                     subscription_type=oauth_token.subscription_type,
                     credentials_path=str(validation.path) if validation.path else None,
                 )
             else:
-                logger.info("auth_token_valid", credentials_path=str(validation.path))
+                logger.debug("auth_token_valid", credentials_path=str(validation.path))
         elif validation.expired:
             logger.warning(
                 "auth_token_expired",
@@ -108,32 +136,63 @@ async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
             "auth_token_validation_error",
             error=str(e),
             message="Failed to validate authentication token. The server will continue without authentication.",
+            exc_info=True,
         )
 
-    # Validate Claude binary at startup
-    claude_path, found_in_path = settings.claude.find_claude_cli()
-    if claude_path:
-        logger.info(
-            "claude_binary_found",
-            path=claude_path,
-            found_in_path=found_in_path,
-            message=f"Claude CLI binary found at: {claude_path}",
+    # Validate Claude binary at startup using the new function
+    try:
+        claude_info = await get_claude_cli_info()
+
+        if claude_info.status == "available":
+            logger.info(
+                "claude_cli_available",
+                status=claude_info.status,
+                version=claude_info.version,
+                binary_path=claude_info.binary_path,
+            )
+        else:
+            logger.warning(
+                "claude_cli_unavailable",
+                status=claude_info.status,
+                error=claude_info.error,
+                binary_path=claude_info.binary_path,
+                message=f"Claude CLI status: {claude_info.status}",
+            )
+    except Exception as e:
+        logger.error(
+            "claude_cli_check_failed",
+            error=str(e),
+            message="Failed to check Claude CLI status during startup",
         )
-    else:
-        searched_paths = settings.claude.get_searched_paths()
-        logger.warning(
-            "claude_binary_not_found",
-            message="Claude CLI binary not found. Please install Claude CLI to use SDK features.",
-            searched_paths=searched_paths,
-            install_command="npm install -g @anthropic-ai/claude-code",
+
+    # Initialize ClaudeSDKService and store in app state
+    try:
+        # Create auth manager with settings
+        auth_manager = CredentialsAuthManager()
+
+        # Get global metrics instance
+        metrics = get_metrics()
+
+        # Create ClaudeSDKService instance
+        claude_service = ClaudeSDKService(
+            auth_manager=auth_manager,
+            metrics=metrics,
+            settings=settings,
         )
 
+        # Store in app state for reuse in dependencies
+        app.state.claude_service = claude_service
+        logger.debug("claude_sdk_service_initialized")
+    except Exception as e:
+        logger.error("claude_sdk_service_initialization_failed", error=str(e))
+        # Continue startup even if ClaudeSDKService fails (graceful degradation)
+
     # Start scheduler system
     try:
         scheduler = await start_scheduler(settings)
         app.state.scheduler = scheduler
         logger.debug("scheduler_initialized")
-    except Exception as e:
+    except SchedulerError as e:
         logger.error("scheduler_initialization_failed", error=str(e))
         # Continue startup even if scheduler fails (graceful degradation)
 
@@ -158,19 +217,81 @@ async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
             logger.error("log_storage_initialization_failed", error=str(e))
             # Continue without log storage (graceful degradation)
 
+    # Initialize permission service
+    try:
+        permission_service = get_permission_service()
+
+        # Only connect terminal handler if not using external handler
+        if settings.server.use_terminal_permission_handler:
+            # terminal_handler = TerminalPermissionHandler()
+
+            # TODO: Terminal handler should subscribe to events from the service
+            # instead of trying to set a handler directly
+            # The service uses an event-based architecture, not direct handlers
+
+            # logger.info(
+            #     "permission_handler_configured",
+            #     handler_type="terminal",
+            #     message="Connected terminal handler to permission service",
+            # )
+            # app.state.terminal_handler = terminal_handler
+            pass
+        else:
+            logger.debug(
+                "permission_handler_configured",
+                handler_type="external_sse",
+                message="Terminal permission handler disabled - use 'ccproxy permission-handler connect' to handle permissions",
+            )
+            logger.warning(
+                "permission_handler_required",
+                message="Start external handler with: ccproxy permission-handler connect",
+            )
+
+        # Start the permission service
+        await permission_service.start()
+
+        # Store references in app state
+        app.state.permission_service = permission_service
+
+        logger.debug(
+            "permission_service_initialized",
+            timeout_seconds=permission_service._timeout_seconds,
+            terminal_handler_enabled=settings.server.use_terminal_permission_handler,
+        )
+    except Exception as e:
+        logger.error("permission_service_initialization_failed", error=str(e))
+        # Continue without permission service (API will work but without prompts)
+
     yield
 
     # Shutdown
     logger.debug("server_stop")
 
+    # Flush any remaining streaming log batches
+    try:
+        from ccproxy.utils.simple_request_logger import flush_all_streaming_batches
+
+        await flush_all_streaming_batches()
+        logger.debug("streaming_batches_flushed")
+    except Exception as e:
+        logger.error("streaming_batches_flush_failed", error=str(e))
+
     # Stop scheduler system
     try:
         scheduler = getattr(app.state, "scheduler", None)
         await stop_scheduler(scheduler)
-        logger.debug("scheduler_stopped")
-    except Exception as e:
+        logger.debug("scheduler_stopped_lifespan")
+    except SchedulerError as e:
         logger.error("scheduler_stop_failed", error=str(e))
 
+    # Stop permission service
+    if hasattr(app.state, "permission_service") and app.state.permission_service:
+        try:
+            await app.state.permission_service.stop()
+            logger.debug("permission_service_stopped")
+        except Exception as e:
+            logger.error("permission_service_stop_failed", error=str(e))
+
     # Close log storage if initialized
     if hasattr(app.state, "log_storage") and app.state.log_storage:
         try:
@@ -191,28 +312,28 @@ def create_app(settings: Settings | None = None) -> FastAPI:
     """
     if settings is None:
         settings = get_settings()
-
     # Configure logging based on settings BEFORE any module uses logger
     # This is needed for reload mode where the app is re-imported
-    import logging
 
     import structlog
 
-    from ccproxy.config.settings import config_manager
-
     # Only configure if not already configured or if no file handler exists
-    root_logger = logging.getLogger()
-    has_file_handler = any(
-        isinstance(h, logging.FileHandler) for h in root_logger.handlers
-    )
-
-    if not structlog.is_configured() or not has_file_handler:
-        # Only setup logging if not already configured with file handler
-        # Always use console output
+    # okay we have the first debug line but after uvicorn start they are not show root_logger = logging.getLogger()
+    # for h in root_logger.handlers:
+    #     print(h)
+    # has_file_handler = any(
+    #     isinstance(h, logging.FileHandler) for h in root_logger.handlers
+    # )
+
+    if not structlog.is_configured():
+        # Only setup logging if structlog is not configured at all
+        # Always use console output, but respect file logging from settings
         json_logs = False
-        # Don't override file logging if it was already configured
-        if not has_file_handler:
-            setup_logging(json_logs=json_logs, log_level=settings.server.log_level)
+        setup_logging(
+            json_logs=json_logs,
+            log_level_name=settings.server.log_level,
+            log_file=settings.server.log_file,
+        )
 
     app = FastAPI(
         title="CCProxy API Server",
@@ -225,10 +346,13 @@ def create_app(settings: Settings | None = None) -> FastAPI:
     setup_cors_middleware(app, settings)
     setup_error_handlers(app)
 
-    # Add custom access log middleware first (will run second due to middleware order)
+    # Add request content logging middleware first (will run third due to middleware order)
+    app.add_middleware(RequestContentLoggingMiddleware)
+
+    # Add custom access log middleware second (will run second due to middleware order)
     app.add_middleware(AccessLogMiddleware)
 
-    # Add request ID middleware second (will run first to initialize context)
+    # Add request ID middleware third (will run first to initialize context)
     app.add_middleware(RequestIDMiddleware)
 
     # Add server header middleware (for non-proxy routes)
@@ -243,7 +367,7 @@ def create_app(settings: Settings | None = None) -> FastAPI:
         app.include_router(prometheus_router, tags=["metrics"])
 
     if settings.observability.logs_endpoints_enabled:
-        app.include_router(logs_router, tags=["logs"])
+        app.include_router(logs_router, prefix="/logs", tags=["logs"])
 
     if settings.observability.dashboard_enabled:
         app.include_router(dashboard_router, tags=["dashboard"])
@@ -256,6 +380,15 @@ def create_app(settings: Settings | None = None) -> FastAPI:
     # New /api/ routes for proxy endpoints (includes OpenAI-compatible /v1/chat/completions)
     app.include_router(proxy_router, prefix="/api", tags=["proxy-api"])
 
+    # Shared models endpoints for both SDK and proxy APIs
+    app.include_router(models_router, prefix="/sdk", tags=["claude-sdk", "models"])
+    app.include_router(models_router, prefix="/api", tags=["proxy-api", "models"])
+
+    # Confirmation endpoints for SSE streaming and responses
+    app.include_router(permissions_router, prefix="/permissions", tags=["permissions"])
+
+    setup_mcp(app)
+
     # Mount static files for dashboard SPA
     from pathlib import Path
 

ccproxy/api/dependencies.py

@@ -5,7 +5,7 @@ from typing import Annotated
 from fastapi import Depends, Request
 from structlog import get_logger
 
-from ccproxy.auth.dependencies import AuthManagerDep, get_auth_manager
+from ccproxy.auth.dependencies import AuthManagerDep
 from ccproxy.config.settings import Settings, get_settings
 from ccproxy.core.http import BaseProxyClient
 from ccproxy.observability import PrometheusMetrics, get_metrics
@@ -17,8 +17,67 @@ from ccproxy.services.proxy_service import ProxyService
 
 logger = get_logger(__name__)
 
+
+def get_cached_settings(request: Request) -> Settings:
+    """Get cached settings from app state.
+
+    This avoids recomputing settings on every request by using the
+    settings instance computed during application startup.
+
+    Args:
+        request: FastAPI request object
+
+    Returns:
+        Settings instance from app state
+
+    Raises:
+        RuntimeError: If settings are not available in app state
+    """
+    settings = getattr(request.app.state, "settings", None)
+    if settings is None:
+        # Fallback to get_settings() for safety, but this should not happen
+        # in normal operation after lifespan startup
+        logger.warning(
+            "Settings not found in app state, falling back to get_settings()"
+        )
+        settings = get_settings()
+    return settings
+
+
+def get_cached_claude_service(request: Request) -> ClaudeSDKService:
+    """Get cached ClaudeSDKService from app state.
+
+    This avoids recreating the ClaudeSDKService on every request by using the
+    service instance created during application startup.
+
+    Args:
+        request: FastAPI request object
+
+    Returns:
+        ClaudeSDKService instance from app state
+
+    Raises:
+        RuntimeError: If ClaudeSDKService is not available in app state
+    """
+    claude_service = getattr(request.app.state, "claude_service", None)
+    if claude_service is None:
+        # Fallback to get_claude_service() for safety, but this should not happen
+        # in normal operation after lifespan startup
+        logger.warning(
+            "ClaudeSDKService not found in app state, falling back to get_claude_service()"
+        )
+        # Get dependencies manually for fallback
+        settings = get_cached_settings(request)
+        # Create a simple auth manager for fallback
+        from ccproxy.auth.credentials_adapter import CredentialsAuthManager
+
+        auth_manager = CredentialsAuthManager()
+        claude_service = get_claude_service(settings, auth_manager)
+    return claude_service
+
+
 # Type aliases for dependency injection
-SettingsDep = Annotated[Settings, Depends(get_settings)]
+SettingsDep = Annotated[Settings, Depends(get_cached_settings)]
 
 
 def get_claude_service(
@@ -134,7 +193,7 @@ async def get_duckdb_storage(request: Request) -> SimpleDuckDBStorage | None:
 
 
 # Type aliases for service dependencies
-ClaudeServiceDep = Annotated[ClaudeSDKService, Depends(get_claude_service)]
+ClaudeServiceDep = Annotated[ClaudeSDKService, Depends(get_cached_claude_service)]
 ProxyServiceDep = Annotated[ProxyService, Depends(get_proxy_service)]
 ObservabilityMetricsDep = Annotated[
     PrometheusMetrics, Depends(get_observability_metrics)

ccproxy/api/middleware/errors.py

@@ -1,9 +1,5 @@
 """Error handling middleware for CCProxy API Server."""
 
-import logging
-from typing import Any
-
-import structlog
 from fastapi import FastAPI, HTTPException, Request
 from fastapi.responses import JSONResponse
 from starlette.exceptions import HTTPException as StarletteHTTPException
@@ -582,10 +578,10 @@ def setup_error_handlers(app: FastAPI) -> None:
         else:
             # Log with basic stack trace (no local variables)
             stack_trace = None
-            if logger.isEnabledFor(logging.DEBUG):
-                import traceback
+            # For structlog, we can always include traceback since structlog handles filtering
+            import traceback
 
-                stack_trace = traceback.format_exc()
+            stack_trace = traceback.format_exc()
 
             logger.error(
                 "HTTP exception",

ccproxy/api/middleware/headers.py

@@ -1,7 +1,5 @@
 """Header preservation middleware to maintain proxy response headers."""
 
-from collections.abc import Callable
-
 from fastapi import Request, Response
 from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint
 from starlette.types import ASGIApp

ccproxy/api/middleware/logging.py

@@ -1,13 +1,15 @@
 """Access logging middleware for structured HTTP request/response logging."""
 
 import time
-from typing import Any, Optional
+from typing import Any
 
 import structlog
 from fastapi import Request, Response
 from starlette.middleware.base import BaseHTTPMiddleware
 from starlette.types import ASGIApp
 
+from ccproxy.api.dependencies import get_cached_settings
+
 
 logger = structlog.get_logger(__name__)
 
@@ -37,9 +39,8 @@ class AccessLogMiddleware(BaseHTTPMiddleware):
         start_time = time.perf_counter()
 
         # Store log storage in request state if collection is enabled
-        from ccproxy.config.settings import get_settings
 
-        settings = get_settings()
+        settings = get_cached_settings(request)
 
         if settings.observability.logs_collection_enabled and hasattr(
             request.app.state, "log_storage"