ccproxy-api 0.1.0__py3-none-any.whl

ccproxy/auth/storage/keyring.py

@@ -0,0 +1,192 @@
+"""OS keyring storage implementation for token storage."""
+
+import json
+from typing import Optional
+
+import keyring
+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 KeyringTokenStorage(TokenStorage):
+    """OS keyring storage implementation for Claude credentials."""
+
+    def __init__(
+        self, service_name: str = "claude-code-proxy", username: str = "default"
+    ):
+        """Initialize keyring storage.
+
+        Args:
+            service_name: Name of the service in the keyring
+            username: Username to associate with the stored credentials
+        """
+        self.service_name = service_name
+        self.username = username
+
+    async def load(self) -> ClaudeCredentials | None:
+        """Load credentials from the OS keyring.
+
+        Returns:
+            Parsed credentials if found and valid, None otherwise
+
+        Raises:
+            CredentialsStorageError: If the stored data is invalid
+            CredentialsStorageError: If there's an error reading from keyring
+        """
+        try:
+            import keyring
+        except ImportError as e:
+            raise CredentialsStorageError(
+                "keyring package is required for keyring storage. "
+                "Install it with: pip install keyring"
+            ) from e
+
+        try:
+            logger.debug(
+                "credentials_load_start",
+                source="keyring",
+                service_name=self.service_name,
+            )
+            password = keyring.get_password(self.service_name, self.username)
+
+            if password is None:
+                logger.debug(
+                    "credentials_not_found",
+                    source="keyring",
+                    service_name=self.service_name,
+                )
+                return None
+
+            # Parse the stored JSON
+            data = json.loads(password)
+            credentials = ClaudeCredentials.model_validate(data)
+
+            self._log_credential_details(credentials)
+            return credentials
+
+        except json.JSONDecodeError as e:
+            raise CredentialsStorageError(
+                f"Failed to parse credentials from keyring: {e}"
+            ) from e
+        except Exception as e:
+            raise CredentialsStorageError(
+                f"Error loading credentials from keyring: {e}"
+            ) from e
+
+    def _log_credential_details(self, credentials: ClaudeCredentials) -> None:
+        """Log credential details safely."""
+        oauth_token = credentials.claude_ai_oauth
+        logger.debug(
+            "credentials_load_completed",
+            source="keyring",
+            subscription_type=oauth_token.subscription_type,
+            expires_at=str(oauth_token.expires_at_datetime),
+            is_expired=oauth_token.is_expired,
+            scopes=oauth_token.scopes,
+        )
+
+    async def save(self, credentials: ClaudeCredentials) -> bool:
+        """Save credentials to the OS keyring.
+
+        Args:
+            credentials: Credentials to save
+
+        Returns:
+            True if saved successfully, False otherwise
+
+        Raises:
+            CredentialsStorageError: If there's an error writing to keyring
+        """
+        try:
+            import keyring
+        except ImportError as e:
+            raise CredentialsStorageError(
+                "keyring package is required for keyring storage. "
+                "Install it with: pip install keyring"
+            ) from e
+
+        try:
+            # Convert to JSON string
+            data = credentials.model_dump(by_alias=True)
+            json_data = json.dumps(data)
+
+            # Store in keyring
+            keyring.set_password(self.service_name, self.username, json_data)
+
+            logger.debug(
+                "credentials_save_completed",
+                source="keyring",
+                service_name=self.service_name,
+            )
+            return True
+
+        except Exception as e:
+            raise CredentialsStorageError(
+                f"Error saving credentials to keyring: {e}"
+            ) from e
+
+    async def exists(self) -> bool:
+        """Check if credentials exist in the keyring.
+
+        Returns:
+            True if credentials exist, False otherwise
+        """
+        try:
+            import keyring
+        except ImportError:
+            return False
+
+        try:
+            password = keyring.get_password(self.service_name, self.username)
+            return password is not None
+        except Exception:
+            return False
+
+    async def delete(self) -> bool:
+        """Delete credentials from the keyring.
+
+        Returns:
+            True if deleted successfully, False otherwise
+
+        Raises:
+            CredentialsStorageError: If there's an error deleting from keyring
+        """
+        try:
+            import keyring
+        except ImportError as e:
+            raise CredentialsStorageError(
+                "keyring package is required for keyring storage. "
+                "Install it with: pip install keyring"
+            ) from e
+
+        try:
+            if await self.exists():
+                keyring.delete_password(self.service_name, self.username)
+                logger.debug(
+                    "credentials_delete_completed",
+                    source="keyring",
+                    service_name=self.service_name,
+                )
+                return True
+            return False
+        except Exception as e:
+            raise CredentialsStorageError(
+                f"Error deleting credentials from keyring: {e}"
+            ) from e
+
+    def get_location(self) -> str:
+        """Get the storage location description.
+
+        Returns:
+            Description of the keyring storage location
+        """
+        return f"OS keyring (service: {self.service_name}, user: {self.username})"

ccproxy/claude_sdk/__init__.py

@@ -0,0 +1,20 @@
+"""Claude SDK integration module."""
+
+from .client import (
+    ClaudeSDKClient,
+    ClaudeSDKConnectionError,
+    ClaudeSDKError,
+    ClaudeSDKProcessError,
+)
+from .converter import MessageConverter
+from .options import OptionsHandler
+
+
+__all__ = [
+    "ClaudeSDKClient",
+    "ClaudeSDKError",
+    "ClaudeSDKConnectionError",
+    "ClaudeSDKProcessError",
+    "MessageConverter",
+    "OptionsHandler",
+]

ccproxy/claude_sdk/client.py

@@ -0,0 +1,169 @@
+"""Claude SDK client wrapper for handling core Claude Code SDK interactions."""
+
+from collections.abc import AsyncIterator
+from typing import Any
+
+import structlog
+
+from ccproxy.core.async_utils import patched_typing
+from ccproxy.core.errors import ClaudeProxyError, ServiceUnavailableError
+from ccproxy.observability import timed_operation
+
+
+with patched_typing():
+    from claude_code_sdk import (
+        AssistantMessage,
+        ClaudeCodeOptions,
+        CLIConnectionError,
+        CLIJSONDecodeError,
+        CLINotFoundError,
+        ProcessError,
+        ResultMessage,
+        SystemMessage,
+        UserMessage,
+        query,
+    )
+
+logger = structlog.get_logger(__name__)
+
+
+class ClaudeSDKError(Exception):
+    """Base exception for Claude SDK errors."""
+
+
+class ClaudeSDKConnectionError(ClaudeSDKError):
+    """Raised when unable to connect to Claude Code."""
+
+
+class ClaudeSDKProcessError(ClaudeSDKError):
+    """Raised when Claude Code process fails."""
+
+
+class ClaudeSDKClient:
+    """
+    Minimal Claude SDK client wrapper that handles core SDK interactions.
+
+    This class provides a clean interface to the Claude Code SDK while handling
+    error translation and basic query execution.
+    """
+
+    def __init__(self) -> None:
+        """Initialize the Claude SDK client."""
+        self._last_api_call_time_ms: float = 0.0
+
+    async def query_completion(
+        self, prompt: str, options: ClaudeCodeOptions, request_id: str | None = None
+    ) -> AsyncIterator[UserMessage | AssistantMessage | SystemMessage | ResultMessage]:
+        """
+        Execute a query using the Claude Code SDK.
+
+        Args:
+            prompt: The prompt string to send to Claude
+            options: Claude Code options configuration
+            request_id: Optional request ID for correlation
+
+        Yields:
+            Messages from the Claude Code SDK
+
+        Raises:
+            ClaudeSDKError: If the query fails
+        """
+        async with timed_operation("claude_sdk_query", request_id) as op:
+            try:
+                logger.debug("claude_sdk_query_start", prompt_length=len(prompt))
+
+                message_count = 0
+                async for message in query(prompt=prompt, options=options):
+                    message_count += 1
+                    yield message
+
+                # Store final metrics
+                op["message_count"] = message_count
+                self._last_api_call_time_ms = op.get("duration_ms", 0.0)
+
+                logger.debug(
+                    "claude_sdk_query_completed",
+                    message_count=message_count,
+                    duration_ms=op.get("duration_ms"),
+                )
+
+            except (CLINotFoundError, CLIConnectionError) as e:
+                logger.error(
+                    "claude_sdk_connection_failed",
+                    error=str(e),
+                    error_type=type(e).__name__,
+                )
+                raise ServiceUnavailableError(
+                    f"Claude CLI not available: {str(e)}"
+                ) from e
+            except (ProcessError, CLIJSONDecodeError) as e:
+                logger.error(
+                    "claude_sdk_process_failed",
+                    error=str(e),
+                    error_type=type(e).__name__,
+                )
+                raise ClaudeProxyError(
+                    message=f"Claude process error: {str(e)}",
+                    error_type="service_unavailable_error",
+                    status_code=503,
+                ) from e
+            except Exception as e:
+                logger.error(
+                    "claude_sdk_unexpected_error_occurred",
+                    error=str(e),
+                    error_type=type(e).__name__,
+                )
+                raise ClaudeProxyError(
+                    message=f"Unexpected error: {str(e)}",
+                    error_type="internal_server_error",
+                    status_code=500,
+                ) from e
+
+    def get_last_api_call_time_ms(self) -> float:
+        """
+        Get the duration of the last Claude API call in milliseconds.
+
+        Returns:
+            Duration in milliseconds, or 0.0 if no call has been made yet
+        """
+        return self._last_api_call_time_ms
+
+    async def validate_health(self) -> bool:
+        """
+        Validate that the Claude SDK is healthy.
+
+        Returns:
+            True if healthy, False otherwise
+        """
+        try:
+            logger.debug("health_check_start", component="claude_sdk")
+
+            # Simple health check - the SDK is available if we can import it
+            # More sophisticated checks could be added here
+            is_healthy = True
+
+            logger.debug(
+                "health_check_completed", component="claude_sdk", healthy=is_healthy
+            )
+            return is_healthy
+        except Exception as e:
+            logger.error(
+                "health_check_failed",
+                component="claude_sdk",
+                error=str(e),
+                error_type=type(e).__name__,
+            )
+            return False
+
+    async def close(self) -> None:
+        """Close the client and cleanup resources."""
+        # Claude Code SDK doesn't require explicit cleanup
+        pass
+
+    async def __aenter__(self) -> "ClaudeSDKClient":
+        """Async context manager entry."""
+        return self
+
+    async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
+        """Async context manager exit."""
+        await self.close()