ccproxy-api 0.1.6__py3-none-any.whl → 0.2.0__py3-none-any.whl

ccproxy/utils/caching.py

@@ -0,0 +1,327 @@
+"""Caching utilities for CCProxy.
+
+This module provides caching decorators and utilities to improve performance
+by caching frequently accessed data like detection results and auth status.
+"""
+
+import functools
+import threading
+import time
+from collections.abc import Callable, Hashable
+from typing import Any, TypeVar
+
+from ccproxy.core.logging import TraceBoundLogger, get_logger
+
+
+logger: TraceBoundLogger = get_logger(__name__)
+
+
+def _trace(message: str, **kwargs: Any) -> None:
+    """Trace-level logger helper with debug fallback."""
+    if hasattr(logger, "trace"):
+        logger.trace(message, **kwargs)
+    else:
+        logger.debug(message, **kwargs)
+
+
+F = TypeVar("F", bound=Callable[..., Any])
+
+
+class TTLCache:
+    """Thread-safe TTL (Time To Live) cache with LRU eviction."""
+
+    def __init__(self, maxsize: int = 128, ttl: float = 300.0):
+        """Initialize TTL cache.
+
+        Args:
+            maxsize: Maximum number of entries to cache
+            ttl: Time to live for entries in seconds
+        """
+        self.maxsize = maxsize
+        self.ttl = ttl
+        self._cache: dict[Hashable, tuple[Any, float]] = {}
+        self._access_order: dict[Hashable, int] = {}
+        self._access_counter = 0
+        self._lock = threading.RLock()
+
+    def get(self, key: Hashable) -> Any | None:
+        """Get value from cache."""
+        with self._lock:
+            if key not in self._cache:
+                return None
+
+            value, expiry_time = self._cache[key]
+
+            # Check if expired
+            if time.time() > expiry_time:
+                self._cache.pop(key, None)
+                self._access_order.pop(key, None)
+                return None
+
+            # Update access order
+            self._access_counter += 1
+            self._access_order[key] = self._access_counter
+
+            return value
+
+    def set(self, key: Hashable, value: Any) -> None:
+        """Set value in cache."""
+        with self._lock:
+            now = time.time()
+            expiry_time = now + self.ttl
+
+            # Add/update entry
+            self._cache[key] = (value, expiry_time)
+            self._access_counter += 1
+            self._access_order[key] = self._access_counter
+
+            # Evict expired entries first
+            self._evict_expired()
+
+            # Evict oldest entries if over maxsize
+            while len(self._cache) > self.maxsize:
+                self._evict_oldest()
+
+    def delete(self, key: Hashable) -> bool:
+        """Delete entry from cache."""
+        with self._lock:
+            if key in self._cache:
+                del self._cache[key]
+                self._access_order.pop(key, None)
+                return True
+            return False
+
+    def clear(self) -> None:
+        """Clear all cache entries."""
+        with self._lock:
+            self._cache.clear()
+            self._access_order.clear()
+            self._access_counter = 0
+
+    def _evict_expired(self) -> None:
+        """Remove expired entries."""
+        now = time.time()
+        expired_keys = [
+            key for key, (_, expiry_time) in self._cache.items() if now > expiry_time
+        ]
+
+        for key in expired_keys:
+            self._cache.pop(key, None)
+            self._access_order.pop(key, None)
+
+    def _evict_oldest(self) -> None:
+        """Remove oldest accessed entry."""
+        if not self._access_order:
+            return
+
+        oldest_key = min(self._access_order, key=lambda k: self._access_order[k])
+        self._cache.pop(oldest_key, None)
+        self._access_order.pop(oldest_key, None)
+
+    def stats(self) -> dict[str, Any]:
+        """Get cache statistics."""
+        with self._lock:
+            return {
+                "size": len(self._cache),
+                "maxsize": self.maxsize,
+                "ttl": self.ttl,
+            }
+
+
+def ttl_cache(maxsize: int = 128, ttl: float = 300.0) -> Callable[[F], F]:
+    """TTL cache decorator for functions.
+
+    Args:
+        maxsize: Maximum number of entries to cache
+        ttl: Time to live for cached results in seconds
+    """
+
+    def decorator(func: F) -> F:
+        cache = TTLCache(maxsize=maxsize, ttl=ttl)
+
+        @functools.wraps(func)
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
+            # Create cache key from function args/kwargs
+            key = _make_cache_key(func.__name__, args, kwargs)
+
+            # Try to get from cache first
+            cached_result = cache.get(key)
+            if cached_result is not None:
+                _trace(
+                    "cache_hit",
+                    function=func.__name__,
+                    key_hash=hash(key) if isinstance(key, tuple) else key,
+                )
+                return cached_result
+
+            # Call function and cache result
+            result = func(*args, **kwargs)
+            cache.set(key, result)
+
+            _trace(
+                "cache_miss_and_set",
+                function=func.__name__,
+                key_hash=hash(key) if isinstance(key, tuple) else key,
+                cache_size=len(cache._cache),
+            )
+
+            return result
+
+        # Add cache management methods
+        wrapper.cache_info = cache.stats  # type: ignore
+        wrapper.cache_clear = cache.clear  # type: ignore
+
+        return wrapper  # type: ignore
+
+    return decorator
+
+
+def async_ttl_cache(
+    maxsize: int = 128, ttl: float = 300.0
+) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
+    """TTL cache decorator for async functions.
+
+    Args:
+        maxsize: Maximum number of entries to cache
+        ttl: Time to live for cached results in seconds
+    """
+
+    def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
+        cache = TTLCache(maxsize=maxsize, ttl=ttl)
+
+        @functools.wraps(func)
+        async def wrapper(*args: Any, **kwargs: Any) -> Any:
+            # Create cache key from function args/kwargs
+            key = _make_cache_key(func.__name__, args, kwargs)
+
+            # Try to get from cache first
+            cached_result = cache.get(key)
+            if cached_result is not None:
+                _trace(
+                    "async_cache_hit",
+                    function=func.__name__,
+                    key_hash=hash(key) if isinstance(key, tuple) else key,
+                )
+                return cached_result
+
+            # Call async function and cache result
+            result = await func(*args, **kwargs)
+            cache.set(key, result)
+
+            _trace(
+                "async_cache_miss_and_set",
+                function=func.__name__,
+                key_hash=hash(key) if isinstance(key, tuple) else key,
+                cache_size=len(cache._cache),
+            )
+
+            return result
+
+        # Add cache management methods
+        wrapper.cache_info = cache.stats  # type: ignore
+        wrapper.cache_clear = cache.clear  # type: ignore
+
+        return wrapper
+
+    return decorator
+
+
+def _make_cache_key(
+    func_name: str, args: tuple[Any, ...], kwargs: dict[str, Any]
+) -> Hashable:
+    """Create a hashable cache key from function arguments."""
+    try:
+        # Try to create a simple key for basic types
+        key_parts = [func_name]
+
+        # Add positional args
+        for arg in args:
+            if hasattr(arg, "__dict__"):
+                # For objects, use class name and id (weak ref to avoid memory leaks)
+                key_parts.append(f"{type(arg).__name__}:{id(arg)}")
+            else:
+                key_parts.append(arg)
+
+        # Add keyword args (sorted for consistency)
+        for k, v in sorted(kwargs.items()):
+            if hasattr(v, "__dict__"):
+                key_parts.append(f"{k}={type(v).__name__}:{id(v)}")
+            else:
+                key_parts.append(f"{k}={v}")
+
+        return tuple(key_parts)
+
+    except (TypeError, ValueError):
+        # Fallback to string representation
+        return f"{func_name}:{hash(str(args))}:{hash(str(sorted(kwargs.items())))}"
+
+
+class AuthStatusCache:
+    """Specialized cache for auth status checks with shorter TTL."""
+
+    def __init__(self, ttl: float = 60.0):  # 1 minute TTL for auth status
+        """Initialize auth status cache.
+
+        Args:
+            ttl: Time to live for auth status in seconds
+        """
+        self._cache = TTLCache(maxsize=32, ttl=ttl)
+
+    def get_auth_status(self, provider: str) -> bool | None:
+        """Get cached auth status for provider."""
+        return self._cache.get(f"auth_status:{provider}")
+
+    def set_auth_status(self, provider: str, is_authenticated: bool) -> None:
+        """Cache auth status for provider."""
+        self._cache.set(f"auth_status:{provider}", is_authenticated)
+
+    def invalidate_auth_status(self, provider: str) -> None:
+        """Invalidate auth status for provider."""
+        self._cache.delete(f"auth_status:{provider}")
+
+    def clear(self) -> None:
+        """Clear all auth status cache."""
+        self._cache.clear()
+
+
+# Global instances for common use cases
+_detection_cache = TTLCache(maxsize=64, ttl=600.0)  # 10 minute TTL for detection
+_auth_cache = AuthStatusCache(ttl=60.0)  # 1 minute TTL for auth status
+_config_cache = TTLCache(maxsize=32, ttl=300.0)  # 5 minute TTL for plugin configs
+
+
+def cache_detection_result(key: str, result: Any) -> None:
+    """Cache a detection result."""
+    _detection_cache.set(f"detection:{key}", result)
+
+
+def get_cached_detection_result(key: str) -> Any | None:
+    """Get cached detection result."""
+    return _detection_cache.get(f"detection:{key}")
+
+
+def cache_plugin_config(plugin_name: str, config: Any) -> None:
+    """Cache plugin configuration."""
+    _config_cache.set(f"plugin_config:{plugin_name}", config)
+
+
+def get_cached_plugin_config(plugin_name: str) -> Any | None:
+    """Get cached plugin configuration."""
+    return _config_cache.get(f"plugin_config:{plugin_name}")
+
+
+def clear_all_caches() -> None:
+    """Clear all global caches."""
+    _detection_cache.clear()
+    _auth_cache.clear()
+    _config_cache.clear()
+    logger.info("all_caches_cleared", category="cache")
+
+
+def get_cache_stats() -> dict[str, Any]:
+    """Get statistics for all caches."""
+    return {
+        "detection_cache": _detection_cache.stats(),
+        "auth_cache": _auth_cache._cache.stats(),
+        "config_cache": _config_cache.stats(),
+    }

ccproxy/utils/cli_logging.py

@@ -0,0 +1,101 @@
+"""Dynamic CLI logging utilities."""
+
+from typing import Any
+
+import structlog
+
+from .binary_resolver import CLIInfo
+
+
+logger = structlog.get_logger(__name__)
+
+
+def log_cli_info(cli_info_dict: dict[str, CLIInfo], context: str = "plugin") -> None:
+    """Log CLI information dynamically for each CLI found.
+
+    Args:
+        cli_info_dict: Dictionary of CLI name -> CLIInfo
+        context: Context for logging (e.g., "plugin", "startup", "detection")
+    """
+    for cli_name, cli_info in cli_info_dict.items():
+        if cli_info["is_available"]:
+            logger.debug(
+                f"{context}_cli_available",
+                cli_name=cli_name,
+                version=cli_info["version"],
+                source=cli_info["source"],
+                path=cli_info["path"],
+                command=cli_info["command"],
+                package_manager=cli_info["package_manager"],
+            )
+        else:
+            logger.warning(
+                f"{context}_cli_unavailable",
+                cli_name=cli_name,
+                expected_version=cli_info["version"],
+            )
+
+
+def log_plugin_summary(summary: dict[str, Any], plugin_name: str) -> None:
+    """Log plugin summary with dynamic CLI information.
+
+    Args:
+        summary: Plugin summary dictionary
+        plugin_name: Name of the plugin
+    """
+    # Log basic plugin info
+    basic_info = {k: v for k, v in summary.items() if k != "cli_info"}
+    logger.debug(
+        "plugin_summary",
+        plugin_name=plugin_name,
+        **basic_info,
+    )
+
+    # Log CLI info dynamically if present
+    if "cli_info" in summary:
+        log_cli_info(summary["cli_info"], f"{plugin_name}_plugin")
+
+
+def format_cli_info_for_display(cli_info: CLIInfo) -> dict[str, str]:
+    """Format CLI info for human-readable display.
+
+    Args:
+        cli_info: CLI information dictionary
+
+    Returns:
+        Formatted dictionary for display
+    """
+    if not cli_info["is_available"]:
+        return {
+            "status": "unavailable",
+            "name": cli_info["name"],
+        }
+
+    display_info = {
+        "status": "available",
+        "name": cli_info["name"],
+        "version": cli_info["version"] or "unknown",
+        "source": cli_info["source"],
+    }
+
+    if cli_info["source"] == "path":
+        display_info["path"] = cli_info["path"] or "unknown"
+    elif cli_info["source"] == "package_manager":
+        display_info["package_manager"] = cli_info["package_manager"] or "unknown"
+        display_info["command"] = " ".join(cli_info["command"])
+
+    return display_info
+
+
+def create_cli_summary_table(cli_info_dict: dict[str, CLIInfo]) -> list[dict[str, str]]:
+    """Create a table-ready summary of all CLI information.
+
+    Args:
+        cli_info_dict: Dictionary of CLI name -> CLIInfo
+
+    Returns:
+        List of formatted CLI info for table display
+    """
+    return [
+        format_cli_info_for_display(cli_info) for cli_info in cli_info_dict.values()
+    ]

ccproxy/utils/command_line.py

@@ -0,0 +1,251 @@
+"""Utilities for generating command line tools (curl, xh) from HTTP request data."""
+
+import json
+import shlex
+from typing import Any
+
+
+def generate_curl_command(
+    method: str,
+    url: str,
+    headers: dict[str, str] | None = None,
+    body: Any = None,
+    is_json: bool = False,
+    pretty: bool = True,
+) -> str:
+    """Generate a curl command from HTTP request parameters.
+
+    Args:
+        method: HTTP method (GET, POST, etc.)
+        url: Target URL
+        headers: HTTP headers dictionary
+        body: Request body (can be dict, str, bytes)
+        is_json: Whether the body should be treated as JSON
+        pretty: Whether to format the command for readability
+
+    Returns:
+        Complete curl command string
+    """
+    parts = ["curl"]
+
+    # Add verbose flag for debugging
+    parts.append("-v")
+
+    # Add method if not GET
+    if method.upper() != "GET":
+        parts.extend(["-X", method.upper()])
+
+    # Add headers
+    if headers:
+        for key, value in headers.items():
+            parts.extend(["-H", f"{key}: {value}"])
+
+    # Add body
+    if isinstance(body, bytes):
+        body_str = body.decode()
+        parts.extend(["-d", body_str])
+
+    # Add URL (always last)
+    parts.append(url)
+
+    if pretty:
+        # Format for readability with line continuations
+        cmd_parts = []
+        for i, part in enumerate(parts):
+            if i == 0:
+                cmd_parts.append(part)
+            elif part in ["-X", "-H", "-d"]:
+                cmd_parts.append(f" \\\n  {part}")
+            elif i == len(parts) - 1:  # URL
+                cmd_parts.append(f" \\\n  {shlex.quote(part)}")
+            else:
+                cmd_parts.append(f" {shlex.quote(part)}")
+        return "".join(cmd_parts)
+    else:
+        # Single line, properly quoted
+        return " ".join(shlex.quote(part) for part in parts)
+
+
+def generate_xh_command(
+    method: str,
+    url: str,
+    headers: dict[str, str] | None = None,
+    body: Any = None,
+    is_json: bool = False,
+    pretty: bool = True,
+) -> str:
+    """Generate an xh (HTTPie-like) command from HTTP request parameters.
+
+    Args:
+        method: HTTP method (GET, POST, etc.)
+        url: Target URL
+        headers: HTTP headers dictionary
+        body: Request body (can be dict, str, bytes)
+        is_json: Whether the body should be treated as JSON
+        pretty: Whether to format the command for readability
+
+    Returns:
+        Complete xh command string
+    """
+    parts = ["xh"]
+
+    # Add verbose flag for debugging
+    parts.append("--verbose")
+
+    # Add method and URL
+    parts.append(f"{method.upper()}")
+    parts.append(url)
+
+    # Add headers
+    if headers:
+        for key, value in headers.items():
+            # Quote the entire header to handle special characters and spaces
+            parts.append(f"{key}:{value}")
+
+    # Add body
+    if isinstance(body, bytes):
+        body_str = body.decode()
+        parts.extend(["-d", body_str])
+
+    if pretty:
+        # Format for readability with line continuations
+        cmd_parts = []
+        for i, part in enumerate(parts):
+            if i == 0:
+                cmd_parts.append(part)
+            elif part == "--verbose" or i == 1:
+                cmd_parts.append(f" {part}")
+            elif i == 2:  # URL
+                cmd_parts.append(f" \\\n  {shlex.quote(part)}")
+            elif part in ("--raw", "-d"):  # flags
+                cmd_parts.append(f" \\\n  {part}")
+            elif ":" in part and not part.startswith("http"):  # header
+                cmd_parts.append(f" \\\n  {shlex.quote(part)}")
+            else:
+                cmd_parts.append(f" {shlex.quote(part)}")
+        return "".join(cmd_parts)
+    else:
+        # Single line, properly quoted
+        return " ".join(shlex.quote(part) for part in parts)
+
+
+def generate_curl_shell_script(
+    method: str,
+    url: str,
+    headers: dict[str, str] | None = None,
+    body: Any = None,
+    is_json: bool = False,
+) -> str:
+    """Generate a shell script with curl command using proper JSON handling.
+
+    This creates a more robust shell script that handles JSON safely by:
+    1. Storing JSON in a variable using heredoc or printf
+    2. Using the variable in the curl command
+
+    Args:
+        method: HTTP method (GET, POST, etc.)
+        url: Target URL
+        headers: HTTP headers dictionary
+        body: Request body (can be dict, str, bytes)
+        is_json: Whether the body should be treated as JSON
+
+    Returns:
+        Complete shell script content
+    """
+    script_lines = ["#!/bin/bash", "set -e", ""]
+
+    # Process JSON body safely
+    json_data = None
+    if body is not None and (is_json or isinstance(body, dict)):
+        if isinstance(body, dict):
+            json_data = json.dumps(
+                body, indent=2, separators=(",", ": "), ensure_ascii=False
+            )
+        else:
+            # Clean up string body
+            body_str = str(body)
+            if (body_str.startswith("b'") and body_str.endswith("'")) or (
+                body_str.startswith('b"') and body_str.endswith('"')
+            ):
+                body_str = body_str[2:-1]
+
+            body_str = body_str.replace('\\"', '"').replace("\\'", "'")
+
+            try:
+                parsed = json.loads(body_str)
+                json_data = json.dumps(
+                    parsed, indent=2, separators=(",", ": "), ensure_ascii=False
+                )
+            except (json.JSONDecodeError, ValueError):
+                json_data = body_str
+
+    # Build curl command parts
+    curl_parts = ["curl", "-v"]
+
+    if method.upper() != "GET":
+        curl_parts.extend(["-X", shlex.quote(method.upper())])
+
+    # Add headers
+    if headers:
+        for key, value in headers.items():
+            curl_parts.extend(["-H", shlex.quote(f"{key}: {value}")])
+
+    # Handle JSON body with heredoc
+    if json_data:
+        script_lines.append("# JSON payload")
+        script_lines.append("JSON_DATA=$(cat <<'EOF'")
+        script_lines.append(json_data)
+        script_lines.append("EOF")
+        script_lines.append(")")
+        script_lines.append("")
+
+        curl_parts.extend(["-d", '"$JSON_DATA"'])
+
+        # Add content-type if not present
+        if not headers or not any(k.lower() == "content-type" for k in headers):
+            curl_parts.extend(["-H", shlex.quote("Content-Type: application/json")])
+    elif body is not None:
+        # Non-JSON body
+        curl_parts.extend(["-d", shlex.quote(str(body))])
+
+    # Add URL
+    curl_parts.append(shlex.quote(url))
+
+    # Build final command
+    script_lines.append("# Execute curl command")
+    script_lines.append(" ".join(curl_parts))
+    script_lines.append("")
+
+    return "\n".join(script_lines)
+
+
+def format_command_output(
+    request_id: str,
+    curl_command: str,
+    xh_command: str,
+    provider: str | None = None,
+) -> str:
+    """Format the command output for logging.
+
+    Args:
+        request_id: Request ID for correlation
+        curl_command: Generated curl command
+        xh_command: Generated xh command
+        provider: Provider name (optional)
+
+    Returns:
+        Formatted output string
+    """
+    provider_info = f" ({provider})" if provider else ""
+
+    return f"""
+🔄 Request Replay Commands{provider_info} [ID: {request_id}]
+
+📋 curl:
+{curl_command}
+
+📋 xh:
+{xh_command}
+
+─────────────────────────────────────────────────────────────────────
+"""