PyPI - ccproxy-api - Versions diffs - 0.1.0__py3-none-any.whl - Mend

ccproxy-api 0.1.0__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (148) hide show

ccproxy/__init__.py +4 -0
ccproxy/__main__.py +7 -0
ccproxy/_version.py +21 -0
ccproxy/adapters/__init__.py +11 -0
ccproxy/adapters/base.py +80 -0
ccproxy/adapters/openai/__init__.py +43 -0
ccproxy/adapters/openai/adapter.py +915 -0
ccproxy/adapters/openai/models.py +412 -0
ccproxy/adapters/openai/streaming.py +449 -0
ccproxy/api/__init__.py +28 -0
ccproxy/api/app.py +225 -0
ccproxy/api/dependencies.py +140 -0
ccproxy/api/middleware/__init__.py +11 -0
ccproxy/api/middleware/auth.py +0 -0
ccproxy/api/middleware/cors.py +55 -0
ccproxy/api/middleware/errors.py +703 -0
ccproxy/api/middleware/headers.py +51 -0
ccproxy/api/middleware/logging.py +175 -0
ccproxy/api/middleware/request_id.py +69 -0
ccproxy/api/middleware/server_header.py +62 -0
ccproxy/api/responses.py +84 -0
ccproxy/api/routes/__init__.py +16 -0
ccproxy/api/routes/claude.py +181 -0
ccproxy/api/routes/health.py +489 -0
ccproxy/api/routes/metrics.py +1033 -0
ccproxy/api/routes/proxy.py +238 -0
ccproxy/auth/__init__.py +75 -0
ccproxy/auth/bearer.py +68 -0
ccproxy/auth/credentials_adapter.py +93 -0
ccproxy/auth/dependencies.py +229 -0
ccproxy/auth/exceptions.py +79 -0
ccproxy/auth/manager.py +102 -0
ccproxy/auth/models.py +118 -0
ccproxy/auth/oauth/__init__.py +26 -0
ccproxy/auth/oauth/models.py +49 -0
ccproxy/auth/oauth/routes.py +396 -0
ccproxy/auth/oauth/storage.py +0 -0
ccproxy/auth/storage/__init__.py +12 -0
ccproxy/auth/storage/base.py +57 -0
ccproxy/auth/storage/json_file.py +159 -0
ccproxy/auth/storage/keyring.py +192 -0
ccproxy/claude_sdk/__init__.py +20 -0
ccproxy/claude_sdk/client.py +169 -0
ccproxy/claude_sdk/converter.py +331 -0
ccproxy/claude_sdk/options.py +120 -0
ccproxy/cli/__init__.py +14 -0
ccproxy/cli/commands/__init__.py +8 -0
ccproxy/cli/commands/auth.py +553 -0
ccproxy/cli/commands/config/__init__.py +14 -0
ccproxy/cli/commands/config/commands.py +766 -0
ccproxy/cli/commands/config/schema_commands.py +119 -0
ccproxy/cli/commands/serve.py +630 -0
ccproxy/cli/docker/__init__.py +34 -0
ccproxy/cli/docker/adapter_factory.py +157 -0
ccproxy/cli/docker/params.py +278 -0
ccproxy/cli/helpers.py +144 -0
ccproxy/cli/main.py +193 -0
ccproxy/cli/options/__init__.py +14 -0
ccproxy/cli/options/claude_options.py +216 -0
ccproxy/cli/options/core_options.py +40 -0
ccproxy/cli/options/security_options.py +48 -0
ccproxy/cli/options/server_options.py +117 -0
ccproxy/config/__init__.py +40 -0
ccproxy/config/auth.py +154 -0
ccproxy/config/claude.py +124 -0
ccproxy/config/cors.py +79 -0
ccproxy/config/discovery.py +87 -0
ccproxy/config/docker_settings.py +265 -0
ccproxy/config/loader.py +108 -0
ccproxy/config/observability.py +158 -0
ccproxy/config/pricing.py +88 -0
ccproxy/config/reverse_proxy.py +31 -0
ccproxy/config/scheduler.py +89 -0
ccproxy/config/security.py +14 -0
ccproxy/config/server.py +81 -0
ccproxy/config/settings.py +534 -0
ccproxy/config/validators.py +231 -0
ccproxy/core/__init__.py +274 -0
ccproxy/core/async_utils.py +675 -0
ccproxy/core/constants.py +97 -0
ccproxy/core/errors.py +256 -0
ccproxy/core/http.py +328 -0
ccproxy/core/http_transformers.py +428 -0
ccproxy/core/interfaces.py +247 -0
ccproxy/core/logging.py +189 -0
ccproxy/core/middleware.py +114 -0
ccproxy/core/proxy.py +143 -0
ccproxy/core/system.py +38 -0
ccproxy/core/transformers.py +259 -0
ccproxy/core/types.py +129 -0
ccproxy/core/validators.py +288 -0
ccproxy/docker/__init__.py +67 -0
ccproxy/docker/adapter.py +588 -0
ccproxy/docker/docker_path.py +207 -0
ccproxy/docker/middleware.py +103 -0
ccproxy/docker/models.py +228 -0
ccproxy/docker/protocol.py +192 -0
ccproxy/docker/stream_process.py +264 -0
ccproxy/docker/validators.py +173 -0
ccproxy/models/__init__.py +123 -0
ccproxy/models/errors.py +42 -0
ccproxy/models/messages.py +243 -0
ccproxy/models/requests.py +85 -0
ccproxy/models/responses.py +227 -0
ccproxy/models/types.py +102 -0
ccproxy/observability/__init__.py +51 -0
ccproxy/observability/access_logger.py +400 -0
ccproxy/observability/context.py +447 -0
ccproxy/observability/metrics.py +539 -0
ccproxy/observability/pushgateway.py +366 -0
ccproxy/observability/sse_events.py +303 -0
ccproxy/observability/stats_printer.py +755 -0
ccproxy/observability/storage/__init__.py +1 -0
ccproxy/observability/storage/duckdb_simple.py +665 -0
ccproxy/observability/storage/models.py +55 -0
ccproxy/pricing/__init__.py +19 -0
ccproxy/pricing/cache.py +212 -0
ccproxy/pricing/loader.py +267 -0
ccproxy/pricing/models.py +106 -0
ccproxy/pricing/updater.py +309 -0
ccproxy/scheduler/__init__.py +39 -0
ccproxy/scheduler/core.py +335 -0
ccproxy/scheduler/exceptions.py +34 -0
ccproxy/scheduler/manager.py +186 -0
ccproxy/scheduler/registry.py +150 -0
ccproxy/scheduler/tasks.py +484 -0
ccproxy/services/__init__.py +10 -0
ccproxy/services/claude_sdk_service.py +614 -0
ccproxy/services/credentials/__init__.py +55 -0
ccproxy/services/credentials/config.py +105 -0
ccproxy/services/credentials/manager.py +562 -0
ccproxy/services/credentials/oauth_client.py +482 -0
ccproxy/services/proxy_service.py +1536 -0
ccproxy/static/.keep +0 -0
ccproxy/testing/__init__.py +34 -0
ccproxy/testing/config.py +148 -0
ccproxy/testing/content_generation.py +197 -0
ccproxy/testing/mock_responses.py +262 -0
ccproxy/testing/response_handlers.py +161 -0
ccproxy/testing/scenarios.py +241 -0
ccproxy/utils/__init__.py +6 -0
ccproxy/utils/cost_calculator.py +210 -0
ccproxy/utils/streaming_metrics.py +199 -0
ccproxy_api-0.1.0.dist-info/METADATA +253 -0
ccproxy_api-0.1.0.dist-info/RECORD +148 -0
ccproxy_api-0.1.0.dist-info/WHEEL +4 -0
ccproxy_api-0.1.0.dist-info/entry_points.txt +2 -0
ccproxy_api-0.1.0.dist-info/licenses/LICENSE +21 -0

ccproxy/auth/oauth/routes.py ADDED Viewed

@@ -0,0 +1,396 @@
+"""OAuth authentication routes for Anthropic OAuth login."""
+import asyncio
+import logging
+from pathlib import Path
+from typing import Any
+from fastapi import APIRouter, HTTPException, Query, Request
+from fastapi.responses import HTMLResponse
+from structlog import get_logger
+from ccproxy.auth.models import (
+    ClaudeCredentials,
+    OAuthToken,
+)
+from ccproxy.auth.storage import JsonFileTokenStorage as JsonFileStorage
+# Import CredentialsManager locally to avoid circular import
+from ccproxy.services.credentials.config import OAuthConfig
+logger = get_logger(__name__)
+router = APIRouter(tags=["oauth"])
+# Store for pending OAuth flows
+_pending_flows: dict[str, dict[str, Any]] = {}
+def register_oauth_flow(
+    state: str, code_verifier: str, custom_paths: list[Path] | None = None
+) -> None:
+    """Register a pending OAuth flow."""
+    _pending_flows[state] = {
+        "code_verifier": code_verifier,
+        "custom_paths": custom_paths,
+        "completed": False,
+        "success": False,
+        "error": None,
+    }
+    logger.debug("Registered OAuth flow", state=state, operation="register_oauth_flow")
+def get_oauth_flow_result(state: str) -> dict[str, Any] | None:
+    """Get and remove OAuth flow result."""
+    return _pending_flows.pop(state, None)
+@router.get("/callback")
+async def oauth_callback(
+    request: Request,
+    code: str | None = Query(None, description="Authorization code"),
+    state: str | None = Query(None, description="State parameter"),
+    error: str | None = Query(None, description="OAuth error"),
+    error_description: str | None = Query(None, description="OAuth error description"),
+) -> HTMLResponse:
+    """Handle OAuth callback from Claude authentication.
+    This endpoint receives the authorization code from Claude's OAuth flow
+    and exchanges it for access tokens.
+    """
+    try:
+        if error:
+            error_msg = error_description or error or "OAuth authentication failed"
+            logger.error(
+                "OAuth callback error",
+                error_type="oauth_error",
+                error_message=error_msg,
+                oauth_error=error,
+                oauth_error_description=error_description,
+                state=state,
+                operation="oauth_callback",
+            )
+            # Update pending flow if state is provided
+            if state and state in _pending_flows:
+                _pending_flows[state].update(
+                    {
+                        "completed": True,
+                        "success": False,
+                        "error": error_msg,
+                    }
+                )
+            return HTMLResponse(
+                content=f"""
+                <html>
+                    <head><title>Login Failed</title></head>
+                    <body>
+                        <h1>Login Failed</h1>
+                        <p>Error: {error_msg}</p>
+                        <p>You can close this window and try again.</p>
+                    </body>
+                </html>
+                """,
+                status_code=400,
+            )
+        if not code:
+            error_msg = "No authorization code received"
+            logger.error(
+                "OAuth callback missing authorization code",
+                error_type="missing_code",
+                error_message=error_msg,
+                state=state,
+                operation="oauth_callback",
+            )
+            if state and state in _pending_flows:
+                _pending_flows[state].update(
+                    {
+                        "completed": True,
+                        "success": False,
+                        "error": error_msg,
+                    }
+                )
+            return HTMLResponse(
+                content=f"""
+                <html>
+                    <head><title>Login Failed</title></head>
+                    <body>
+                        <h1>Login Failed</h1>
+                        <p>Error: {error_msg}</p>
+                        <p>You can close this window and try again.</p>
+                    </body>
+                </html>
+                """,
+                status_code=400,
+            )
+        if not state:
+            error_msg = "Missing state parameter"
+            logger.error(
+                "OAuth callback missing state parameter",
+                error_type="missing_state",
+                error_message=error_msg,
+                operation="oauth_callback",
+            )
+            return HTMLResponse(
+                content=f"""
+                <html>
+                    <head><title>Login Failed</title></head>
+                    <body>
+                        <h1>Login Failed</h1>
+                        <p>Error: {error_msg}</p>
+                        <p>You can close this window and try again.</p>
+                    </body>
+                </html>
+                """,
+                status_code=400,
+            )
+        # Check if this is a valid pending flow
+        if state not in _pending_flows:
+            error_msg = "Invalid or expired state parameter"
+            logger.error(
+                "OAuth callback with invalid state",
+                error_type="invalid_state",
+                error_message="Invalid or expired state parameter",
+                state=state,
+                operation="oauth_callback",
+            )
+            return HTMLResponse(
+                content=f"""
+                <html>
+                    <head><title>Login Failed</title></head>
+                    <body>
+                        <h1>Login Failed</h1>
+                        <p>Error: {error_msg}</p>
+                        <p>You can close this window and try again.</p>
+                    </body>
+                </html>
+                """,
+                status_code=400,
+            )
+        # Get flow details
+        flow = _pending_flows[state]
+        code_verifier = flow["code_verifier"]
+        custom_paths = flow["custom_paths"]
+        # Exchange authorization code for tokens
+        success = await _exchange_code_for_tokens(code, code_verifier, custom_paths)
+        # Update flow result
+        _pending_flows[state].update(
+            {
+                "completed": True,
+                "success": success,
+                "error": None if success else "Token exchange failed",
+            }
+        )
+        if success:
+            logger.info(
+                "OAuth login successful", state=state, operation="oauth_callback"
+            )
+            return HTMLResponse(
+                content="""
+                <html>
+                    <head><title>Login Successful</title></head>
+                    <body>
+                        <h1>Login Successful!</h1>
+                        <p>You have successfully logged in to Claude.</p>
+                        <p>You can close this window and return to the CLI.</p>
+                        <script>
+                            setTimeout(() => {
+                                window.close();
+                            }, 3000);
+                        </script>
+                    </body>
+                </html>
+                """,
+                status_code=200,
+            )
+        else:
+            error_msg = "Failed to exchange authorization code for tokens"
+            logger.error(
+                "OAuth token exchange failed",
+                error_type="token_exchange_failed",
+                error_message=error_msg,
+                state=state,
+                operation="oauth_callback",
+            )
+            return HTMLResponse(
+                content=f"""
+                <html>
+                    <head><title>Login Failed</title></head>
+                    <body>
+                        <h1>Login Failed</h1>
+                        <p>Error: {error_msg}</p>
+                        <p>You can close this window and try again.</p>
+                    </body>
+                </html>
+                """,
+                status_code=500,
+            )
+    except Exception as e:
+        logger.error(
+            "Unexpected error in OAuth callback",
+            error_type="unexpected_error",
+            error_message=str(e),
+            state=state,
+            operation="oauth_callback",
+            exc_info=True,
+        )
+        if state and state in _pending_flows:
+            _pending_flows[state].update(
+                {
+                    "completed": True,
+                    "success": False,
+                    "error": str(e),
+                }
+            )
+        return HTMLResponse(
+            content=f"""
+            <html>
+                <head><title>Login Error</title></head>
+                <body>
+                    <h1>Login Error</h1>
+                    <p>An unexpected error occurred: {str(e)}</p>
+                    <p>You can close this window and try again.</p>
+                </body>
+            </html>
+            """,
+            status_code=500,
+        )
+async def _exchange_code_for_tokens(
+    authorization_code: str, code_verifier: str, custom_paths: list[Path] | None = None
+) -> bool:
+    """Exchange authorization code for access tokens."""
+    try:
+        from datetime import UTC, datetime
+        import httpx
+        # Create OAuth config with default values
+        oauth_config = OAuthConfig()
+        # Exchange authorization code for tokens
+        token_data = {
+            "grant_type": "authorization_code",
+            "code": authorization_code,
+            "redirect_uri": oauth_config.redirect_uri,
+            "client_id": oauth_config.client_id,
+            "code_verifier": code_verifier,
+        }
+        headers = {
+            "Content-Type": "application/json",
+            "anthropic-beta": oauth_config.beta_version,
+            "User-Agent": oauth_config.user_agent,
+        }
+        async with httpx.AsyncClient() as client:
+            response = await client.post(
+                oauth_config.token_url,
+                headers=headers,
+                json=token_data,
+                timeout=30.0,
+            )
+            if response.status_code == 200:
+                result = response.json()
+                # Calculate expires_at from expires_in
+                expires_in = result.get("expires_in")
+                expires_at = None
+                if expires_in:
+                    expires_at = int(
+                        (datetime.now(UTC).timestamp() + expires_in) * 1000
+                    )
+                # Create credentials object
+                oauth_data = {
+                    "accessToken": result.get("access_token"),
+                    "refreshToken": result.get("refresh_token"),
+                    "expiresAt": expires_at,
+                    "scopes": result.get("scope", "").split()
+                    if result.get("scope")
+                    else oauth_config.scopes,
+                    "subscriptionType": result.get("subscription_type", "unknown"),
+                }
+                credentials = ClaudeCredentials(claudeAiOauth=OAuthToken(**oauth_data))
+                # Save credentials using CredentialsManager (lazy import to avoid circular import)
+                from ccproxy.services.credentials.manager import CredentialsManager
+                if custom_paths:
+                    # Use the first custom path for storage
+                    storage = JsonFileStorage(custom_paths[0])
+                    manager = CredentialsManager(storage=storage)
+                else:
+                    manager = CredentialsManager()
+                if await manager.save(credentials):
+                    logger.info(
+                        "Successfully saved OAuth credentials",
+                        subscription_type=oauth_data["subscriptionType"],
+                        scopes=oauth_data["scopes"],
+                        operation="exchange_code_for_tokens",
+                    )
+                    return True
+                else:
+                    logger.error(
+                        "Failed to save OAuth credentials",
+                        error_type="save_credentials_failed",
+                        operation="exchange_code_for_tokens",
+                    )
+                    return False
+            else:
+                # Use compact logging for the error message
+                import os
+                verbose_api = (
+                    os.environ.get("CCPROXY_VERBOSE_API", "false").lower() == "true"
+                )
+                if verbose_api:
+                    error_detail = response.text
+                else:
+                    response_text = response.text
+                    if len(response_text) > 200:
+                        error_detail = f"{response_text[:100]}...{response_text[-50:]}"
+                    elif len(response_text) > 100:
+                        error_detail = f"{response_text[:100]}..."
+                    else:
+                        error_detail = response_text
+                logger.error(
+                    "Token exchange failed",
+                    error_type="token_exchange_failed",
+                    status_code=response.status_code,
+                    error_detail=error_detail,
+                    verbose_api_enabled=verbose_api,
+                    operation="exchange_code_for_tokens",
+                )
+                return False
+    except Exception as e:
+        logger.error(
+            "Error during token exchange",
+            error_type="token_exchange_exception",
+            error_message=str(e),
+            operation="exchange_code_for_tokens",
+            exc_info=True,
+        )
+        return False

ccproxy/auth/oauth/storage.py ADDED Viewed

File without changes

ccproxy/auth/storage/__init__.py ADDED Viewed

@@ -0,0 +1,12 @@
+"""Token storage implementations for authentication."""
+from ccproxy.auth.storage.base import TokenStorage
+from ccproxy.auth.storage.json_file import JsonFileTokenStorage
+from ccproxy.auth.storage.keyring import KeyringTokenStorage
+__all__ = [
+    "TokenStorage",
+    "JsonFileTokenStorage",
+    "KeyringTokenStorage",
+]

ccproxy/auth/storage/base.py ADDED Viewed

@@ -0,0 +1,57 @@
+"""Abstract base class for token storage."""
+from abc import ABC, abstractmethod
+from ccproxy.auth.models import ClaudeCredentials
+class TokenStorage(ABC):
+    """Abstract interface for token storage operations."""
+    @abstractmethod
+    async def load(self) -> ClaudeCredentials | None:
+        """Load credentials from storage.
+        Returns:
+            Parsed credentials if found and valid, None otherwise
+        """
+        pass
+    @abstractmethod
+    async def save(self, credentials: ClaudeCredentials) -> bool:
+        """Save credentials to storage.
+        Args:
+            credentials: Credentials to save
+        Returns:
+            True if saved successfully, False otherwise
+        """
+        pass
+    @abstractmethod
+    async def exists(self) -> bool:
+        """Check if credentials exist in storage.
+        Returns:
+            True if credentials exist, False otherwise
+        """
+        pass
+    @abstractmethod
+    async def delete(self) -> bool:
+        """Delete credentials from storage.
+        Returns:
+            True if deleted successfully, False otherwise
+        """
+        pass
+    @abstractmethod
+    def get_location(self) -> str:
+        """Get the storage location description.
+        Returns:
+            Human-readable description of where credentials are stored
+        """
+        pass

ccproxy/auth/storage/json_file.py ADDED Viewed

@@ -0,0 +1,159 @@
+"""JSON file storage implementation for token storage."""
+import contextlib
+import json
+from pathlib import Path
+from typing import Optional
+from structlog import get_logger
+from ccproxy.auth.exceptions import (
+    CredentialsInvalidError,
+    CredentialsStorageError,
+)
+from ccproxy.auth.models import ClaudeCredentials
+from ccproxy.auth.storage.base import TokenStorage
+logger = get_logger(__name__)
+class JsonFileTokenStorage(TokenStorage):
+    """JSON file storage implementation for Claude credentials with keyring fallback."""
+    def __init__(self, file_path: Path):
+        """Initialize JSON file storage.
+        Args:
+            file_path: Path to the JSON credentials file
+        """
+        self.file_path = file_path
+    async def load(self) -> ClaudeCredentials | None:
+        """Load credentials from JSON file .
+        Returns:
+            Parsed credentials if found and valid, None otherwise
+        Raises:
+            CredentialsInvalidError: If the JSON file is invalid
+            CredentialsStorageError: If there's an error reading the file
+        """
+        if not await self.exists():
+            logger.debug("credentials_file_not_found", path=str(self.file_path))
+            return None
+        try:
+            logger.debug(
+                "credentials_load_start", source="file", path=str(self.file_path)
+            )
+            with self.file_path.open() as f:
+                data = json.load(f)
+            credentials = ClaudeCredentials.model_validate(data)
+            logger.debug("credentials_load_completed", source="file")
+            return credentials
+        except json.JSONDecodeError as e:
+            raise CredentialsInvalidError(
+                f"Failed to parse credentials file {self.file_path}: {e}"
+            ) from e
+        except Exception as e:
+            raise CredentialsStorageError(
+                f"Error loading credentials from {self.file_path}: {e}"
+            ) from e
+    async def save(self, credentials: ClaudeCredentials) -> bool:
+        """Save credentials to both keyring and JSON file.
+        Args:
+            credentials: Credentials to save
+        Returns:
+            True if saved successfully, False otherwise
+        Raises:
+            CredentialsStorageError: If there's an error writing the file
+        """
+        try:
+            # Convert to dict with proper aliases
+            data = credentials.model_dump(by_alias=True, mode="json")
+            # Always save to file as well
+            # Ensure parent directory exists
+            self.file_path.parent.mkdir(parents=True, exist_ok=True)
+            # Use atomic write: write to temp file then rename
+            temp_path = self.file_path.with_suffix(".tmp")
+            try:
+                with temp_path.open("w") as f:
+                    json.dump(data, f, indent=2)
+                # Set appropriate file permissions (read/write for owner only)
+                temp_path.chmod(0o600)
+                # Atomically replace the original file
+                Path.replace(temp_path, self.file_path)
+                logger.debug(
+                    "credentials_save_completed",
+                    source="file",
+                    path=str(self.file_path),
+                )
+                return True
+            except Exception as e:
+                raise
+            finally:
+                # Clean up temp file if it exists
+                if temp_path.exists():
+                    with contextlib.suppress(Exception):
+                        temp_path.unlink()
+        except Exception as e:
+            raise CredentialsStorageError(f"Error saving credentials: {e}") from e
+    async def exists(self) -> bool:
+        """Check if credentials file exists.
+        Returns:
+            True if file exists, False otherwise
+        """
+        return self.file_path.exists() and self.file_path.is_file()
+    async def delete(self) -> bool:
+        """Delete credentials from both keyring and file.
+        Returns:
+            True if deleted successfully, False otherwise
+        Raises:
+            CredentialsStorageError: If there's an error deleting the file
+        """
+        deleted = False
+        # Delete from file
+        try:
+            if await self.exists():
+                self.file_path.unlink()
+                logger.debug(
+                    "credentials_delete_completed",
+                    source="file",
+                    path=str(self.file_path),
+                )
+                deleted = True
+        except Exception as e:
+            if not deleted:  # Only raise if we failed to delete from both
+                raise CredentialsStorageError(f"Error deleting credentials: {e}") from e
+            logger.debug("credentials_delete_partial", source="file", error=str(e))
+        return deleted
+    def get_location(self) -> str:
+        """Get the storage location description.
+        Returns:
+            Path to the JSON file with keyring info if available
+        """
+        return str(self.file_path)