ccproxy-api 0.1.4__py3-none-any.whl → 0.1.5__py3-none-any.whl

ccproxy/scheduler/manager.py

@@ -7,6 +7,7 @@ from ccproxy.config.settings import Settings
 from .core import Scheduler
 from .registry import register_task
 from .tasks import (
+    PoolStatsTask,
     PricingCacheUpdateTask,
     PushgatewayTask,
     StatsPrintingTask,
@@ -31,6 +32,19 @@ async def setup_scheduler_tasks(scheduler: Scheduler, settings: Settings) -> Non
         logger.info("scheduler_disabled")
         return
 
+    # Log network features status
+    logger.info(
+        "network_features_status",
+        pricing_updates_enabled=scheduler_config.pricing_update_enabled,
+        version_check_enabled=scheduler_config.version_check_enabled,
+        message=(
+            "Network features disabled by default for privacy"
+            if not scheduler_config.pricing_update_enabled
+            and not scheduler_config.version_check_enabled
+            else "Some network features are enabled"
+        ),
+    )
+
     # Add pushgateway task if enabled
     if scheduler_config.pushgateway_enabled:
         try:
@@ -123,21 +137,32 @@ async def setup_scheduler_tasks(scheduler: Scheduler, settings: Settings) -> Non
             )
 
 
-def _register_default_tasks() -> None:
-    """Register default task types in the global registry."""
+def _register_default_tasks(settings: Settings) -> None:
+    """Register default task types in the global registry based on configuration."""
     from .registry import get_task_registry
 
     registry = get_task_registry()
+    scheduler_config = settings.scheduler
 
-    # Only register if not already registered
-    if not registry.is_registered("pushgateway"):
+    # Only register pushgateway task if enabled
+    if scheduler_config.pushgateway_enabled and not registry.is_registered(
+        "pushgateway"
+    ):
         register_task("pushgateway", PushgatewayTask)
-    if not registry.is_registered("stats_printing"):
+
+    # Only register stats printing task if enabled
+    if scheduler_config.stats_printing_enabled and not registry.is_registered(
+        "stats_printing"
+    ):
         register_task("stats_printing", StatsPrintingTask)
+
+    # Always register core tasks (not metrics-related)
     if not registry.is_registered("pricing_cache_update"):
         register_task("pricing_cache_update", PricingCacheUpdateTask)
     if not registry.is_registered("version_update_check"):
         register_task("version_update_check", VersionUpdateCheckTask)
+    if not registry.is_registered("pool_stats"):
+        register_task("pool_stats", PoolStatsTask)
 
 
 async def start_scheduler(settings: Settings) -> Scheduler | None:
@@ -156,7 +181,7 @@ async def start_scheduler(settings: Settings) -> Scheduler | None:
             return None
 
         # Register task types (only when actually starting scheduler)
-        _register_default_tasks()
+        _register_default_tasks(settings)
 
         # Create scheduler with settings
         scheduler = Scheduler(

ccproxy/scheduler/tasks.py

@@ -483,6 +483,128 @@ class PricingCacheUpdateTask(BaseScheduledTask):
             return False
 
 
+class PoolStatsTask(BaseScheduledTask):
+    """Task for displaying pool statistics periodically."""
+
+    def __init__(
+        self,
+        name: str,
+        interval_seconds: float,
+        enabled: bool = True,
+        pool_manager: Any | None = None,
+    ):
+        """
+        Initialize pool stats task.
+
+        Args:
+            name: Task name
+            interval_seconds: Interval between stats display
+            enabled: Whether task is enabled
+            pool_manager: Injected pool manager instance
+        """
+        super().__init__(
+            name=name,
+            interval_seconds=interval_seconds,
+            enabled=enabled,
+        )
+        self._pool_manager = pool_manager
+
+    async def setup(self) -> None:
+        """Initialize pool manager instance if not injected."""
+        if self._pool_manager is None:
+            logger.warning(
+                "pool_stats_task_no_manager",
+                task_name=self.name,
+                message="Pool manager not injected, task will be disabled",
+            )
+
+    async def run(self) -> bool:
+        """Display pool statistics."""
+        try:
+            if not self._pool_manager:
+                return True  # Not an error, just no pool manager available
+
+            # Get general pool stats (if available)
+            general_pool = getattr(self._pool_manager, "_pool", None)
+            general_stats = None
+            if general_pool:
+                general_stats = general_pool.get_stats()
+
+            # Get session pool stats
+            session_pool = getattr(self._pool_manager, "_session_pool", None)
+            session_stats = None
+            if session_pool:
+                session_stats = await session_pool.get_stats()
+
+            # Log pool statistics
+            logger.debug(
+                "pool_stats_report",
+                task_name=self.name,
+                general_pool={
+                    "enabled": bool(general_pool),
+                    "total_clients": general_stats.total_clients
+                    if general_stats
+                    else 0,
+                    "available_clients": general_stats.available_clients
+                    if general_stats
+                    else 0,
+                    "active_clients": general_stats.active_clients
+                    if general_stats
+                    else 0,
+                    "connections_created": general_stats.connections_created
+                    if general_stats
+                    else 0,
+                    "connections_closed": general_stats.connections_closed
+                    if general_stats
+                    else 0,
+                    "acquire_count": general_stats.acquire_count
+                    if general_stats
+                    else 0,
+                    "release_count": general_stats.release_count
+                    if general_stats
+                    else 0,
+                    "health_check_failures": general_stats.health_check_failures
+                    if general_stats
+                    else 0,
+                }
+                if general_pool
+                else None,
+                session_pool={
+                    "enabled": session_stats.get("enabled", False)
+                    if session_stats
+                    else False,
+                    "total_sessions": session_stats.get("total_sessions", 0)
+                    if session_stats
+                    else 0,
+                    "active_sessions": session_stats.get("active_sessions", 0)
+                    if session_stats
+                    else 0,
+                    "max_sessions": session_stats.get("max_sessions", 0)
+                    if session_stats
+                    else 0,
+                    "total_messages": session_stats.get("total_messages", 0)
+                    if session_stats
+                    else 0,
+                    "session_ttl": session_stats.get("session_ttl", 0)
+                    if session_stats
+                    else 0,
+                }
+                if session_pool
+                else None,
+            )
+
+            return True
+
+        except Exception as e:
+            logger.error(
+                "pool_stats_task_error",
+                task_name=self.name,
+                error=str(e),
+                error_type=type(e).__name__,
+            )
+            return False
+
+
 class VersionUpdateCheckTask(BaseScheduledTask):
     """Task for checking version updates periodically."""
 

ccproxy/services/claude_detection_service.py

@@ -0,0 +1,269 @@
+"""Service for automatically detecting Claude CLI headers at startup."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import socket
+import subprocess
+from typing import Any
+
+import structlog
+from fastapi import FastAPI, Request, Response
+
+from ccproxy.config.discovery import get_ccproxy_cache_dir
+from ccproxy.config.settings import Settings
+from ccproxy.models.detection import (
+    ClaudeCacheData,
+    ClaudeCodeHeaders,
+    SystemPromptData,
+)
+
+
+logger = structlog.get_logger(__name__)
+
+
+class ClaudeDetectionService:
+    """Service for automatically detecting Claude CLI headers at startup."""
+
+    def __init__(self, settings: Settings) -> None:
+        """Initialize Claude detection service."""
+        self.settings = settings
+        self.cache_dir = get_ccproxy_cache_dir()
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+        self._cached_data: ClaudeCacheData | None = None
+
+    async def initialize_detection(self) -> ClaudeCacheData:
+        """Initialize Claude detection at startup."""
+        try:
+            # Get current Claude version
+            current_version = await self._get_claude_version()
+
+            # Try to load from cache first
+            detected_data = self._load_from_cache(current_version)
+            cached = detected_data is not None
+            if cached:
+                logger.debug("detection_claude_headers_debug", version=current_version)
+            else:
+                # No cache or version changed - detect fresh
+                detected_data = await self._detect_claude_headers(current_version)
+                # Cache the results
+                self._save_to_cache(detected_data)
+
+            self._cached_data = detected_data
+
+            logger.info(
+                "detection_claude_headers_completed",
+                version=current_version,
+                cached=cached,
+            )
+
+            # TODO: add proper testing without claude cli installed
+            if detected_data is None:
+                raise ValueError("Claude detection failed")
+            return detected_data
+
+        except Exception as e:
+            logger.warning("detection_claude_headers_failed", fallback=True, error=e)
+            # Return fallback data
+            fallback_data = self._get_fallback_data()
+            self._cached_data = fallback_data
+            return fallback_data
+
+    def get_cached_data(self) -> ClaudeCacheData | None:
+        """Get currently cached detection data."""
+        return self._cached_data
+
+    async def _get_claude_version(self) -> str:
+        """Get Claude CLI version."""
+        try:
+            result = subprocess.run(
+                ["claude", "--version"],
+                capture_output=True,
+                text=True,
+                timeout=10,
+            )
+            if result.returncode == 0:
+                # Extract version from output like "1.0.60 (Claude Code)"
+                version_line = result.stdout.strip()
+                if "/" in version_line:
+                    # Handle "claude-cli/1.0.60" format
+                    version_line = version_line.split("/")[-1]
+                if "(" in version_line:
+                    # Handle "1.0.60 (Claude Code)" format - extract just the version number
+                    return version_line.split("(")[0].strip()
+                return version_line
+            else:
+                raise RuntimeError(f"Claude version command failed: {result.stderr}")
+
+        except (subprocess.TimeoutExpired, FileNotFoundError, RuntimeError) as e:
+            logger.warning("claude_version_detection_failed", error=str(e))
+            return "unknown"
+
+    async def _detect_claude_headers(self, version: str) -> ClaudeCacheData:
+        """Execute Claude CLI with proxy to capture headers and system prompt."""
+        # Data captured from the request
+        captured_data: dict[str, Any] = {}
+
+        async def capture_handler(request: Request) -> Response:
+            """Capture the Claude CLI request."""
+            captured_data["headers"] = dict(request.headers)
+            captured_data["body"] = await request.body()
+            # Return a mock response to satisfy Claude CLI
+            return Response(
+                content='{"type": "message", "content": [{"type": "text", "text": "Test response"}]}',
+                media_type="application/json",
+                status_code=200,
+            )
+
+        # Create temporary FastAPI app
+        temp_app = FastAPI()
+        temp_app.post("/v1/messages")(capture_handler)
+
+        # Find available port
+        sock = socket.socket()
+        sock.bind(("", 0))
+        port = sock.getsockname()[1]
+        sock.close()
+
+        # Start server in background
+        from uvicorn import Config, Server
+
+        config = Config(temp_app, host="127.0.0.1", port=port, log_level="error")
+        server = Server(config)
+
+        server_task = asyncio.create_task(server.serve())
+
+        try:
+            # Wait for server to start
+            await asyncio.sleep(0.5)
+
+            # Execute Claude CLI with proxy
+            env = {**dict(os.environ), "ANTHROPIC_BASE_URL": f"http://127.0.0.1:{port}"}
+
+            process = await asyncio.create_subprocess_exec(
+                "claude",
+                "test",
+                env=env,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+            )
+
+            # Wait for process with timeout
+            try:
+                await asyncio.wait_for(process.wait(), timeout=30)
+            except TimeoutError:
+                process.kill()
+                await process.wait()
+
+            # Stop server
+            server.should_exit = True
+            await server_task
+
+            if not captured_data:
+                raise RuntimeError("Failed to capture Claude CLI request")
+
+            # Extract headers and system prompt
+            headers = self._extract_headers(captured_data["headers"])
+            system_prompt = self._extract_system_prompt(captured_data["body"])
+
+            return ClaudeCacheData(
+                claude_version=version, headers=headers, system_prompt=system_prompt
+            )
+
+        except Exception as e:
+            # Ensure server is stopped
+            server.should_exit = True
+            if not server_task.done():
+                await server_task
+            raise
+
+    def _load_from_cache(self, version: str) -> ClaudeCacheData | None:
+        """Load cached data for specific Claude version."""
+        cache_file = self.cache_dir / f"claude_headers_{version}.json"
+
+        if not cache_file.exists():
+            return None
+
+        try:
+            with cache_file.open("r") as f:
+                data = json.load(f)
+                return ClaudeCacheData.model_validate(data)
+        except Exception:
+            return None
+
+    def _save_to_cache(self, data: ClaudeCacheData) -> None:
+        """Save detection data to cache."""
+        cache_file = self.cache_dir / f"claude_headers_{data.claude_version}.json"
+
+        try:
+            with cache_file.open("w") as f:
+                json.dump(data.model_dump(), f, indent=2, default=str)
+            logger.debug(
+                "cache_saved", file=str(cache_file), version=data.claude_version
+            )
+        except Exception as e:
+            logger.warning("cache_save_failed", file=str(cache_file), error=str(e))
+
+    def _extract_headers(self, headers: dict[str, str]) -> ClaudeCodeHeaders:
+        """Extract Claude CLI headers from captured request."""
+        try:
+            return ClaudeCodeHeaders.model_validate(headers)
+        except Exception as e:
+            logger.error("header_extraction_failed", error=str(e))
+            raise ValueError(f"Failed to extract required headers: {e}") from e
+
+    def _extract_system_prompt(self, body: bytes) -> SystemPromptData:
+        """Extract system prompt from captured request body."""
+        try:
+            data = json.loads(body.decode("utf-8"))
+            system_content = data.get("system")
+
+            if system_content is None:
+                raise ValueError("No system field found in request body")
+
+            return SystemPromptData(system_field=system_content)
+
+        except Exception as e:
+            logger.error("system_prompt_extraction_failed", error=str(e))
+            raise ValueError(f"Failed to extract system prompt: {e}") from e
+
+    def _get_fallback_data(self) -> ClaudeCacheData:
+        """Get fallback data when detection fails."""
+        logger.warning("using_fallback_claude_data")
+
+        # Use existing hardcoded values as fallback
+        fallback_headers = ClaudeCodeHeaders(
+            **{
+                "anthropic-beta": "claude-code-20250219,oauth-2025-04-20,interleaved-thinking-2025-05-14,fine-grained-tool-streaming-2025-05-14",
+                "anthropic-version": "2023-06-01",
+                "anthropic-dangerous-direct-browser-access": "true",
+                "x-app": "cli",
+                "User-Agent": "claude-cli/1.0.60 (external, cli)",
+                "X-Stainless-Lang": "js",
+                "X-Stainless-Retry-Count": "0",
+                "X-Stainless-Timeout": "60",
+                "X-Stainless-Package-Version": "0.55.1",
+                "X-Stainless-OS": "Linux",
+                "X-Stainless-Arch": "x64",
+                "X-Stainless-Runtime": "node",
+                "X-Stainless-Runtime-Version": "v24.3.0",
+            }
+        )
+
+        fallback_prompt = SystemPromptData(
+            system_field=[
+                {
+                    "type": "text",
+                    "text": "You are Claude Code, Anthropic's official CLI for Claude.",
+                    "cache_control": {"type": "ephemeral"},
+                }
+            ]
+        )
+
+        return ClaudeCacheData(
+            claude_version="fallback",
+            headers=fallback_headers,
+            system_prompt=fallback_prompt,
+        )