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

ccproxy/auth/storage/json_file.py

@@ -1,158 +0,0 @@
-"""JSON file storage implementation for token storage."""
-
-import contextlib
-import json
-from pathlib import Path
-
-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)

ccproxy/auth/storage/keyring.py

@@ -1,189 +0,0 @@
-"""OS keyring storage implementation for token storage."""
-
-import json
-
-from structlog import get_logger
-
-from ccproxy.auth.exceptions import (
-    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

@@ -1,18 +0,0 @@
-"""Claude SDK integration module."""
-
-from .client import ClaudeSDKClient
-from .converter import MessageConverter
-from .exceptions import ClaudeSDKError, StreamTimeoutError
-from .options import OptionsHandler
-from .parser import parse_formatted_sdk_content
-
-
-__all__ = [
-    # Session Context will be imported here once created
-    "ClaudeSDKClient",
-    "ClaudeSDKError",
-    "StreamTimeoutError",
-    "MessageConverter",
-    "OptionsHandler",
-    "parse_formatted_sdk_content",
-]

ccproxy/claude_sdk/options.py

@@ -1,194 +0,0 @@
-"""Options handling for Claude SDK interactions."""
-
-from typing import Any
-
-import structlog
-
-from ccproxy.config.settings import Settings
-from ccproxy.core.async_utils import patched_typing
-
-
-with patched_typing():
-    from claude_code_sdk import ClaudeCodeOptions
-
-logger = structlog.get_logger(__name__)
-
-
-class OptionsHandler:
-    """
-    Handles creation and management of Claude SDK options.
-    """
-
-    def __init__(self, settings: Settings | None = None) -> None:
-        """
-        Initialize options handler.
-
-        Args:
-            settings: Application settings containing default Claude options
-        """
-        self.settings = settings
-
-    def create_options(
-        self,
-        model: str,
-        temperature: float | None = None,
-        max_tokens: int | None = None,
-        system_message: str | None = None,
-        **additional_options: Any,
-    ) -> ClaudeCodeOptions:
-        """
-        Create Claude SDK options from API parameters.
-
-        Args:
-            model: The model name
-            temperature: Temperature for response generation
-            max_tokens: Maximum tokens in response
-            system_message: System message to include
-            **additional_options: Additional options to set on the ClaudeCodeOptions instance
-
-        Returns:
-            Configured ClaudeCodeOptions instance
-        """
-        # Start with configured defaults if available, otherwise create fresh instance
-        if self.settings and self.settings.claude.code_options:
-            # Use the configured options as base - this preserves all default settings
-            # including complex objects like mcp_servers and permission_prompt_tool_name
-            configured_opts = self.settings.claude.code_options
-
-            # Create a new instance with the same configuration
-            # We need to extract the configuration values properly with type safety
-
-            # Extract configuration values with proper types
-            mcp_servers = (
-                configured_opts.mcp_servers.copy()
-                if isinstance(configured_opts.mcp_servers, dict)
-                else {}
-            )
-            permission_prompt_tool_name = configured_opts.permission_prompt_tool_name
-            max_thinking_tokens = getattr(configured_opts, "max_thinking_tokens", None)
-            allowed_tools = getattr(configured_opts, "allowed_tools", None)
-            disallowed_tools = getattr(configured_opts, "disallowed_tools", None)
-            cwd = getattr(configured_opts, "cwd", None)
-            append_system_prompt = getattr(
-                configured_opts, "append_system_prompt", None
-            )
-            max_turns = getattr(configured_opts, "max_turns", None)
-            continue_conversation = getattr(
-                configured_opts, "continue_conversation", None
-            )
-            permission_mode = getattr(configured_opts, "permission_mode", None)
-
-            # Build ClaudeCodeOptions with proper type handling
-            # Start with a basic instance and set attributes individually for type safety
-            options = ClaudeCodeOptions(
-                mcp_servers=mcp_servers,
-                permission_prompt_tool_name=permission_prompt_tool_name,
-            )
-
-            # Set additional attributes if they exist and are not None
-            if max_thinking_tokens is not None:
-                options.max_thinking_tokens = int(max_thinking_tokens)
-            if allowed_tools is not None:
-                options.allowed_tools = list(allowed_tools)
-            if disallowed_tools is not None:
-                options.disallowed_tools = list(disallowed_tools)
-            if cwd is not None:
-                options.cwd = cwd
-            if append_system_prompt is not None:
-                options.append_system_prompt = append_system_prompt
-            if max_turns is not None:
-                options.max_turns = max_turns
-            if continue_conversation is not None:
-                options.continue_conversation = bool(continue_conversation)
-            if permission_mode is not None:
-                options.permission_mode = permission_mode
-        else:
-            options = ClaudeCodeOptions()
-
-        # Override the model (API parameter takes precedence)
-        options.model = model
-
-        # Apply system message if provided (this is supported by ClaudeCodeOptions)
-        if system_message is not None:
-            options.system_prompt = system_message
-
-        # If session_id is provided via additional_options, enable continue_conversation
-        # This ensures conversation continuity when using session IDs
-        if additional_options.get("session_id"):
-            options.continue_conversation = True
-
-        # Note: temperature and max_tokens are API-level parameters, not ClaudeCodeOptions parameters
-        # These are handled at the API request level, not in the options object
-
-        # Handle additional options as needed
-        for key, value in additional_options.items():
-            if hasattr(options, key):
-                setattr(options, key, value)
-
-        return options
-
-    @staticmethod
-    def extract_system_message(messages: list[dict[str, Any]]) -> str | None:
-        """
-        Extract system message from Anthropic messages format.
-
-        Args:
-            messages: List of messages in Anthropic format
-
-        Returns:
-            System message content if found, None otherwise
-        """
-        for message in messages:
-            if message.get("role") == "system":
-                content = message.get("content", "")
-                if isinstance(content, list):
-                    # Handle content blocks
-                    text_parts = []
-                    for block in content:
-                        if block.get("type") == "text":
-                            text_parts.append(block.get("text", ""))
-                    return " ".join(text_parts)
-                return str(content)
-        return None
-
-    @staticmethod
-    def get_supported_models() -> list[str]:
-        """
-        Get list of supported Claude models.
-
-        Returns:
-            List of supported model names
-        """
-        # Import here to avoid circular imports
-        from ccproxy.utils.model_mapping import get_supported_claude_models
-
-        # Get supported Claude models
-        claude_models = get_supported_claude_models()
-        return claude_models
-
-    @staticmethod
-    def validate_model(model: str) -> bool:
-        """
-        Validate if a model is supported.
-
-        Args:
-            model: The model name to validate
-
-        Returns:
-            True if supported, False otherwise
-        """
-        return model in OptionsHandler.get_supported_models()
-
-    @staticmethod
-    def get_default_options() -> dict[str, Any]:
-        """
-        Get default options for API parameters.
-
-        Returns:
-            Dictionary of default API parameter values
-        """
-        return {
-            "model": "claude-3-5-sonnet-20241022",
-            "temperature": 0.7,
-            "max_tokens": 4000,
-        }