ccproxy-api 0.1.7__py3-none-any.whl → 0.2.0a4__py3-none-any.whl

ccproxy/api/routes/proxy.py

@@ -1,211 +0,0 @@
-"""Proxy endpoints for CCProxy API Server."""
-
-import json
-from collections.abc import AsyncIterator
-
-from fastapi import APIRouter, HTTPException, Request, Response
-from fastapi.responses import StreamingResponse
-
-from ccproxy.adapters.openai.adapter import OpenAIAdapter
-from ccproxy.api.dependencies import ProxyServiceDep
-from ccproxy.api.responses import ProxyResponse
-from ccproxy.auth.conditional import ConditionalAuthDep
-
-
-# Create the router for proxy endpoints
-router = APIRouter(tags=["proxy"])
-
-
-@router.post("/v1/chat/completions", response_model=None)
-async def create_openai_chat_completion(
-    request: Request,
-    proxy_service: ProxyServiceDep,
-    auth: ConditionalAuthDep,
-) -> StreamingResponse | Response:
-    """Create a chat completion using Claude AI with OpenAI-compatible format.
-
-    This endpoint handles OpenAI API format requests and forwards them
-    directly to Claude via the proxy service.
-    """
-    try:
-        # Get request body
-        body = await request.body()
-
-        # Get headers and query params
-        headers = dict(request.headers)
-        query_params: dict[str, str | list[str]] | None = (
-            dict(request.query_params) if request.query_params else None
-        )
-
-        # Handle the request using proxy service directly
-        # Strip the /api prefix from the path
-        service_path = request.url.path.removeprefix("/api")
-        response = await proxy_service.handle_request(
-            method=request.method,
-            path=service_path,
-            headers=headers,
-            body=body,
-            query_params=query_params,
-            request=request,  # Pass the request object for context access
-        )
-
-        # Return appropriate response type
-        if isinstance(response, StreamingResponse):
-            # Already a streaming response
-            return response
-        else:
-            # Tuple response - handle regular response
-            status_code, response_headers, response_body = response
-            if status_code >= 400:
-                # Store headers for preservation middleware
-                request.state.preserve_headers = response_headers
-                # Forward error response directly with headers
-                return ProxyResponse(
-                    content=response_body,
-                    status_code=status_code,
-                    headers=response_headers,
-                    media_type=response_headers.get("content-type", "application/json"),
-                )
-
-            # Check if this is a streaming response based on content-type
-            content_type = response_headers.get("content-type", "")
-            if "text/event-stream" in content_type:
-                # Return as streaming response
-                async def stream_generator() -> AsyncIterator[bytes]:
-                    # Split the SSE data into chunks
-                    for line in response_body.decode().split("\n"):
-                        if line.strip():
-                            yield f"{line}\n".encode()
-
-                return StreamingResponse(
-                    stream_generator(),
-                    media_type="text/event-stream",
-                    headers={
-                        "Cache-Control": "no-cache",
-                        "Connection": "keep-alive",
-                    },
-                )
-            else:
-                # Parse JSON response
-                response_data = json.loads(response_body.decode())
-
-                # Convert Anthropic response back to OpenAI format for /chat/completions
-                openai_adapter = OpenAIAdapter()
-                openai_response = openai_adapter.adapt_response(response_data)
-
-                # Return response with headers
-                return ProxyResponse(
-                    content=json.dumps(openai_response),
-                    status_code=status_code,
-                    headers=response_headers,
-                    media_type=response_headers.get("content-type", "application/json"),
-                )
-
-    except HTTPException:
-        # Re-raise HTTPException as-is (including 401 auth errors)
-        raise
-    except Exception as e:
-        raise HTTPException(
-            status_code=500, detail=f"Internal server error: {str(e)}"
-        ) from e
-
-
-@router.post("/v1/messages", response_model=None)
-async def create_anthropic_message(
-    request: Request,
-    proxy_service: ProxyServiceDep,
-    auth: ConditionalAuthDep,
-) -> StreamingResponse | Response:
-    """Create a message using Claude AI with Anthropic format.
-
-    This endpoint handles Anthropic API format requests and forwards them
-    directly to Claude via the proxy service.
-    """
-    try:
-        # Get request body
-        body = await request.body()
-
-        # Get headers and query params
-        headers = dict(request.headers)
-        query_params: dict[str, str | list[str]] | None = (
-            dict(request.query_params) if request.query_params else None
-        )
-
-        # Handle the request using proxy service directly
-        # Strip the /api prefix from the path
-        service_path = request.url.path.removeprefix("/api")
-        response = await proxy_service.handle_request(
-            method=request.method,
-            path=service_path,
-            headers=headers,
-            body=body,
-            query_params=query_params,
-            request=request,  # Pass the request object for context access
-        )
-
-        # Return appropriate response type
-        if isinstance(response, StreamingResponse):
-            # Already a streaming response
-            return response
-        else:
-            # Tuple response - handle regular response
-            status_code, response_headers, response_body = response
-            if status_code >= 400:
-                # Store headers for preservation middleware
-                request.state.preserve_headers = response_headers
-                # Forward error response directly with headers
-                return ProxyResponse(
-                    content=response_body,
-                    status_code=status_code,
-                    headers=response_headers,
-                    media_type=response_headers.get("content-type", "application/json"),
-                )
-
-            # Check if this is a streaming response based on content-type
-            content_type = response_headers.get("content-type", "")
-            if "text/event-stream" in content_type:
-                # Return as streaming response
-                async def stream_generator() -> AsyncIterator[bytes]:
-                    # Split the SSE data into chunks
-                    for line in response_body.decode().split("\n"):
-                        if line.strip():
-                            yield f"{line}\n".encode()
-
-                # Start with the response headers from proxy service
-                streaming_headers = response_headers.copy()
-
-                # Ensure critical headers for streaming
-                streaming_headers["Cache-Control"] = "no-cache"
-                streaming_headers["Connection"] = "keep-alive"
-
-                # Set content-type if not already set by upstream
-                if "content-type" not in streaming_headers:
-                    streaming_headers["content-type"] = "text/event-stream"
-
-                return StreamingResponse(
-                    stream_generator(),
-                    media_type="text/event-stream",
-                    headers=streaming_headers,
-                )
-            else:
-                # Store headers for preservation middleware
-                request.state.preserve_headers = response_headers
-
-                # Parse JSON response
-                response_data = json.loads(response_body.decode())
-
-                # Return response with headers
-                return ProxyResponse(
-                    content=response_body,  # Use original body to preserve exact format
-                    status_code=status_code,
-                    headers=response_headers,
-                    media_type=response_headers.get("content-type", "application/json"),
-                )
-
-    except HTTPException:
-        # Re-raise HTTPException as-is (including 401 auth errors)
-        raise
-    except Exception as e:
-        raise HTTPException(
-            status_code=500, detail=f"Internal server error: {str(e)}"
-        ) from e

ccproxy/api/services/__init__.py

@@ -1,6 +0,0 @@
-"""Services for CCProxy API."""
-
-from .permission_service import PermissionService, get_permission_service
-
-
-__all__ = ["PermissionService", "get_permission_service"]

ccproxy/auth/conditional.py

@@ -1,84 +0,0 @@
-"""Conditional authentication dependencies."""
-
-from typing import Annotated
-
-from fastapi import Depends, HTTPException, Request, status
-from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
-
-from ccproxy.api.dependencies import SettingsDep
-from ccproxy.auth.bearer import BearerTokenAuthManager
-from ccproxy.auth.exceptions import AuthenticationError
-from ccproxy.auth.manager import AuthManager
-
-
-# FastAPI security scheme for bearer tokens
-bearer_scheme = HTTPBearer(auto_error=False)
-
-
-async def get_conditional_auth_manager(
-    request: Request,
-    settings: SettingsDep,
-    credentials: Annotated[
-        HTTPAuthorizationCredentials | None, Depends(bearer_scheme)
-    ] = None,
-) -> AuthManager | None:
-    """Get authentication manager only if auth is required.
-
-    This dependency checks if authentication is configured and validates
-    the token if required. If no auth is configured, returns None.
-
-    Args:
-        request: The FastAPI request object
-        credentials: HTTP authorization credentials
-        settings: Application settings
-
-    Returns:
-        AuthManager instance if authenticated, None if no auth required
-
-    Raises:
-        HTTPException: If auth is required but credentials are invalid
-    """
-    # Check if auth is required for this configuration
-    if settings is None or not settings.security.auth_token:
-        # No auth configured, return None
-        return None
-
-    # Auth is required, validate credentials
-    if not credentials or not credentials.credentials:
-        raise HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED,
-            detail="Authentication required",
-            headers={"WWW-Authenticate": "Bearer"},
-        )
-
-    # Validate the token
-    if credentials.credentials != settings.security.auth_token:
-        raise HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED,
-            detail="Invalid authentication credentials",
-            headers={"WWW-Authenticate": "Bearer"},
-        )
-
-    # Create and return auth manager
-    try:
-        bearer_auth = BearerTokenAuthManager(credentials.credentials)
-        if await bearer_auth.is_authenticated():
-            return bearer_auth
-        else:
-            raise HTTPException(
-                status_code=status.HTTP_401_UNAUTHORIZED,
-                detail="Authentication failed",
-                headers={"WWW-Authenticate": "Bearer"},
-            )
-    except (AuthenticationError, ValueError) as e:
-        raise HTTPException(
-            status_code=status.HTTP_401_UNAUTHORIZED,
-            detail=str(e),
-            headers={"WWW-Authenticate": "Bearer"},
-        ) from e
-
-
-# Type alias for conditional auth dependency
-ConditionalAuthDep = Annotated[
-    AuthManager | None, Depends(get_conditional_auth_manager)
-]

ccproxy/auth/credentials_adapter.py

@@ -1,93 +0,0 @@
-"""Adapter to make CredentialsManager compatible with AuthManager interface."""
-
-from typing import Any
-
-from ccproxy.auth.exceptions import (
-    AuthenticationError,
-    CredentialsError,
-    CredentialsExpiredError,
-    CredentialsNotFoundError,
-)
-from ccproxy.auth.manager import BaseAuthManager
-from ccproxy.auth.models import ClaudeCredentials, UserProfile
-from ccproxy.services.credentials.manager import CredentialsManager
-
-
-class CredentialsAuthManager(BaseAuthManager):
-    """Adapter to make CredentialsManager compatible with AuthManager interface."""
-
-    def __init__(self, credentials_manager: CredentialsManager | None = None) -> None:
-        """Initialize with credentials manager.
-
-        Args:
-            credentials_manager: CredentialsManager instance, creates new if None
-        """
-        self._credentials_manager = credentials_manager or CredentialsManager()
-
-    async def get_access_token(self) -> str:
-        """Get valid access token from credentials manager.
-
-        Returns:
-            Access token string
-
-        Raises:
-            AuthenticationError: If authentication fails
-        """
-        try:
-            return await self._credentials_manager.get_access_token()
-        except CredentialsNotFoundError as e:
-            raise AuthenticationError("No credentials found") from e
-        except CredentialsExpiredError as e:
-            raise AuthenticationError("Credentials expired") from e
-        except CredentialsError as e:
-            raise AuthenticationError(f"Credentials error: {e}") from e
-
-    async def get_credentials(self) -> ClaudeCredentials:
-        """Get valid credentials from credentials manager.
-
-        Returns:
-            Valid credentials
-
-        Raises:
-            AuthenticationError: If authentication fails
-        """
-        try:
-            return await self._credentials_manager.get_valid_credentials()
-        except CredentialsNotFoundError as e:
-            raise AuthenticationError("No credentials found") from e
-        except CredentialsExpiredError as e:
-            raise AuthenticationError("Credentials expired") from e
-        except CredentialsError as e:
-            raise AuthenticationError(f"Credentials error: {e}") from e
-
-    async def is_authenticated(self) -> bool:
-        """Check if current authentication is valid.
-
-        Returns:
-            True if authenticated, False otherwise
-        """
-        try:
-            await self._credentials_manager.get_valid_credentials()
-            return True
-        except CredentialsError:
-            return False
-
-    async def get_user_profile(self) -> UserProfile | None:
-        """Get user profile information.
-
-        Returns:
-            UserProfile if available, None otherwise
-        """
-        try:
-            return await self._credentials_manager.fetch_user_profile()
-        except CredentialsError:
-            return None
-
-    async def __aenter__(self) -> "CredentialsAuthManager":
-        """Async context manager entry."""
-        await self._credentials_manager.__aenter__()
-        return self
-
-    async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
-        """Async context manager exit."""
-        await self._credentials_manager.__aexit__(exc_type, exc_val, exc_tb)

ccproxy/auth/models.py

@@ -1,118 +0,0 @@
-"""Data models for authentication."""
-
-from datetime import UTC, datetime
-
-from pydantic import BaseModel, Field
-
-
-class OAuthToken(BaseModel):
-    """OAuth token information from Claude credentials."""
-
-    access_token: str = Field(..., alias="accessToken")
-    refresh_token: str = Field(..., alias="refreshToken")
-    expires_at: int | None = Field(None, alias="expiresAt")
-    scopes: list[str] = Field(default_factory=list)
-    subscription_type: str | None = Field(None, alias="subscriptionType")
-    token_type: str = Field(default="Bearer", alias="tokenType")
-
-    def __repr__(self) -> str:
-        """Safe string representation that masks sensitive tokens."""
-        access_preview = (
-            f"{self.access_token[:8]}...{self.access_token[-8:]}"
-            if len(self.access_token) > 16
-            else "***"
-        )
-        refresh_preview = (
-            f"{self.refresh_token[:8]}...{self.refresh_token[-8:]}"
-            if len(self.refresh_token) > 16
-            else "***"
-        )
-
-        expires_at = (
-            datetime.fromtimestamp(self.expires_at / 1000, tz=UTC).isoformat()
-            if self.expires_at is not None
-            else "None"
-        )
-        return (
-            f"OAuthToken(access_token='{access_preview}', "
-            f"refresh_token='{refresh_preview}', "
-            f"expires_at={expires_at}, "
-            f"scopes={self.scopes}, "
-            f"subscription_type='{self.subscription_type}', "
-            f"token_type='{self.token_type}')"
-        )
-
-    @property
-    def is_expired(self) -> bool:
-        """Check if the token is expired."""
-        if self.expires_at is None:
-            # If no expiration info, assume not expired for backward compatibility
-            return False
-        now = datetime.now(UTC).timestamp() * 1000  # Convert to milliseconds
-        return now >= self.expires_at
-
-    @property
-    def expires_at_datetime(self) -> datetime:
-        """Get expiration as datetime object."""
-        if self.expires_at is None:
-            # Return a far future date if no expiration info
-            return datetime.fromtimestamp(2147483647, tz=UTC)  # Year 2038
-        return datetime.fromtimestamp(self.expires_at / 1000, tz=UTC)
-
-
-class OrganizationInfo(BaseModel):
-    """Organization information from OAuth API."""
-
-    uuid: str
-    name: str
-    organization_type: str | None = None
-    billing_type: str | None = None
-    rate_limit_tier: str | None = None
-
-
-class AccountInfo(BaseModel):
-    """Account information from OAuth API."""
-
-    uuid: str
-    email: str
-    full_name: str | None = None
-    display_name: str | None = None
-    has_claude_max: bool | None = None
-    has_claude_pro: bool | None = None
-
-    @property
-    def email_address(self) -> str:
-        """Compatibility property for email_address."""
-        return self.email
-
-
-class UserProfile(BaseModel):
-    """User profile information from Anthropic OAuth API."""
-
-    organization: OrganizationInfo | None = None
-    account: AccountInfo | None = None
-
-
-class ClaudeCredentials(BaseModel):
-    """Claude credentials from the credentials file."""
-
-    claude_ai_oauth: OAuthToken = Field(..., alias="claudeAiOauth")
-
-    def __repr__(self) -> str:
-        """Safe string representation that masks sensitive tokens."""
-        return f"ClaudeCredentials(claude_ai_oauth={repr(self.claude_ai_oauth)})"
-
-
-class ValidationResult(BaseModel):
-    """Result of credentials validation."""
-
-    valid: bool
-    expired: bool | None = None
-    credentials: ClaudeCredentials | None = None
-    path: str | None = None
-
-
-# Backwards compatibility - provide common aliases
-User = UserProfile
-Credentials = ClaudeCredentials
-Profile = UserProfile

ccproxy/auth/oauth/models.py

@@ -1,48 +0,0 @@
-"""OAuth-specific models for authentication."""
-
-from datetime import datetime
-
-from pydantic import BaseModel, Field
-
-
-class OAuthState(BaseModel):
-    """OAuth state information for pending flows."""
-
-    code_verifier: str = Field(..., description="PKCE code verifier")
-    custom_paths: list[str] | None = Field(None, description="Custom credential paths")
-    completed: bool = Field(default=False, description="Whether the flow is completed")
-    success: bool = Field(default=False, description="Whether the flow was successful")
-    error: str | None = Field(None, description="Error message if failed")
-    created_at: datetime = Field(
-        default_factory=datetime.utcnow, description="Creation timestamp"
-    )
-
-
-class OAuthCallbackRequest(BaseModel):
-    """OAuth callback request parameters."""
-
-    code: str | None = Field(None, description="Authorization code")
-    state: str | None = Field(None, description="State parameter")
-    error: str | None = Field(None, description="OAuth error")
-    error_description: str | None = Field(None, description="OAuth error description")
-
-
-class OAuthTokenRequest(BaseModel):
-    """OAuth token exchange request."""
-
-    grant_type: str = Field(default="authorization_code")
-    code: str = Field(..., description="Authorization code")
-    redirect_uri: str = Field(..., description="Redirect URI")
-    client_id: str = Field(..., description="Client ID")
-    code_verifier: str = Field(..., description="PKCE code verifier")
-
-
-class OAuthTokenResponse(BaseModel):
-    """OAuth token exchange response."""
-
-    access_token: str = Field(..., description="Access token")
-    refresh_token: str | None = Field(None, description="Refresh token")
-    expires_in: int | None = Field(None, description="Token expiration in seconds")
-    scope: str | None = Field(None, description="Granted scopes")
-    subscription_type: str | None = Field(None, description="Subscription type")
-    token_type: str = Field(default="Bearer", description="Token type")

ccproxy/auth/openai/__init__.py

@@ -1,13 +0,0 @@
-"""OpenAI authentication components for Codex integration."""
-
-from .credentials import OpenAICredentials, OpenAITokenManager
-from .oauth_client import OpenAIOAuthClient
-from .storage import OpenAITokenStorage
-
-
-__all__ = [
-    "OpenAICredentials",
-    "OpenAITokenManager",
-    "OpenAIOAuthClient",
-    "OpenAITokenStorage",
-]