ccproxy-api 0.1.0__py3-none-any.whl

ccproxy/config/auth.py

@@ -0,0 +1,154 @@
+"""Authentication and credentials configuration."""
+
+import os
+from pathlib import Path
+from typing import Any
+
+from pydantic import BaseModel, Field, field_validator
+
+
+def _get_default_storage_paths() -> list[Path]:
+    """Get default storage paths"""
+    return [
+        Path("~/.config/claude/.credentials.json"),
+        Path("~/.claude/.credentials.json"),
+        Path("~/.config/ccproxy/credentials.json"),
+    ]
+
+
+class OAuthSettings(BaseModel):
+    """OAuth-specific settings."""
+
+    base_url: str = Field(
+        default="https://console.anthropic.com",
+        description="Base URL for OAuth API endpoints",
+    )
+    beta_version: str = Field(
+        default="oauth-2025-04-20",
+        description="OAuth beta version header",
+    )
+    token_url: str = Field(
+        default="https://console.anthropic.com/v1/oauth/token",
+        description="OAuth token endpoint URL",
+    )
+    authorize_url: str = Field(
+        default="https://claude.ai/oauth/authorize",
+        description="OAuth authorization endpoint URL",
+    )
+    profile_url: str = Field(
+        default="https://api.anthropic.com/api/oauth/profile",
+        description="OAuth profile endpoint URL",
+    )
+    client_id: str = Field(
+        default="9d1c250a-e61b-44d9-88ed-5944d1962f5e",
+        description="OAuth client ID",
+    )
+    redirect_uri: str = Field(
+        default="http://localhost:54545/callback",
+        description="OAuth redirect URI",
+    )
+    scopes: list[str] = Field(
+        default_factory=lambda: [
+            "org:create_api_key",
+            "user:profile",
+            "user:inference",
+        ],
+        description="OAuth scopes to request",
+    )
+    request_timeout: int = Field(
+        default=30,
+        description="Timeout in seconds for OAuth requests",
+    )
+    user_agent: str = Field(
+        default="Claude-Code/1.0.43",
+        description="User agent string for OAuth requests",
+    )
+    callback_timeout: int = Field(
+        default=300,
+        description="Timeout in seconds for OAuth callback",
+        ge=60,
+        le=600,
+    )
+    callback_port: int = Field(
+        default=54545,
+        description="Port for OAuth callback server",
+        ge=1024,
+        le=65535,
+    )
+
+
+class CredentialStorageSettings(BaseModel):
+    """Settings for credential storage locations."""
+
+    storage_paths: list[Path] = Field(
+        default_factory=lambda: _get_default_storage_paths(),
+        description="Paths to search for credentials files",
+    )
+    auto_refresh: bool = Field(
+        default=True,
+        description="Automatically refresh expired tokens",
+    )
+    refresh_buffer_seconds: int = Field(
+        default=300,
+        description="Refresh token this many seconds before expiry",
+        ge=0,
+    )
+
+
+class AuthSettings(BaseModel):
+    """Combined authentication and credentials configuration."""
+
+    oauth: OAuthSettings = Field(
+        default_factory=OAuthSettings,
+        description="OAuth configuration",
+    )
+    storage: CredentialStorageSettings = Field(
+        default_factory=CredentialStorageSettings,
+        description="Credential storage configuration",
+    )
+
+    @field_validator("oauth", mode="before")
+    @classmethod
+    def validate_oauth(cls, v: Any) -> Any:
+        """Validate and convert OAuth configuration."""
+        if v is None:
+            return OAuthSettings()
+
+        # If it's already an OAuthSettings instance, return as-is
+        if isinstance(v, OAuthSettings):
+            return v
+
+        # If it's a dict, create OAuthSettings from it
+        if isinstance(v, dict):
+            return OAuthSettings(**v)
+
+        # Try to convert to dict if possible
+        if hasattr(v, "model_dump"):
+            return OAuthSettings(**v.model_dump())
+        elif hasattr(v, "__dict__"):
+            return OAuthSettings(**v.__dict__)
+
+        return v
+
+    @field_validator("storage", mode="before")
+    @classmethod
+    def validate_storage(cls, v: Any) -> Any:
+        """Validate and convert storage configuration."""
+        if v is None:
+            return CredentialStorageSettings()
+
+        # If it's already a CredentialStorageSettings instance, return as-is
+        if isinstance(v, CredentialStorageSettings):
+            return v
+
+        # If it's a dict, create CredentialStorageSettings from it
+        if isinstance(v, dict):
+            return CredentialStorageSettings(**v)
+
+        # Try to convert to dict if possible
+        if hasattr(v, "model_dump"):
+            return CredentialStorageSettings(**v.model_dump())
+        elif hasattr(v, "__dict__"):
+            return CredentialStorageSettings(**v.__dict__)
+
+        return v

ccproxy/config/claude.py

@@ -0,0 +1,124 @@
+"""Claude-specific configuration settings."""
+
+import os
+import shutil
+from pathlib import Path
+from typing import Any
+
+from pydantic import BaseModel, Field, field_validator
+
+from ccproxy.core.async_utils import get_package_dir, patched_typing
+
+
+# For further information visit https://errors.pydantic.dev/2.11/u/typed-dict-version
+with patched_typing():
+    from claude_code_sdk import ClaudeCodeOptions  # noqa: E402
+
+
+class ClaudeSettings(BaseModel):
+    """Claude-specific configuration settings."""
+
+    cli_path: str | None = Field(
+        default=None,
+        description="Path to Claude CLI executable",
+    )
+
+    code_options: ClaudeCodeOptions = Field(
+        default_factory=lambda: ClaudeCodeOptions(),
+        description="Claude Code SDK options configuration",
+    )
+
+    @field_validator("cli_path")
+    @classmethod
+    def validate_claude_cli_path(cls, v: str | None) -> str | None:
+        """Validate Claude CLI path if provided."""
+        if v is not None:
+            path = Path(v)
+            if not path.exists():
+                raise ValueError(f"Claude CLI path does not exist: {v}")
+            if not path.is_file():
+                raise ValueError(f"Claude CLI path is not a file: {v}")
+            if not os.access(path, os.X_OK):
+                raise ValueError(f"Claude CLI path is not executable: {v}")
+        return v
+
+    @field_validator("code_options", mode="before")
+    @classmethod
+    def validate_claude_code_options(cls, v: Any) -> Any:
+        """Validate and convert Claude Code options."""
+        if v is None:
+            return ClaudeCodeOptions()
+
+        # If it's already a ClaudeCodeOptions instance, return as-is
+        if isinstance(v, ClaudeCodeOptions):
+            return v
+
+        # Try to convert to dict if possible
+        if hasattr(v, "model_dump"):
+            return v.model_dump()
+        elif hasattr(v, "__dict__"):
+            return v.__dict__
+
+        return v
+
+    def find_claude_cli(self) -> tuple[str | None, bool]:
+        """Find Claude CLI executable in PATH or specified location.
+
+        Returns:
+            tuple: (path_to_claude, found_in_path)
+        """
+        if self.cli_path:
+            return self.cli_path, False
+
+        # Try to find claude in PATH
+        claude_path = shutil.which("claude")
+        if claude_path:
+            return claude_path, True
+
+        # Common installation paths (in order of preference)
+        common_paths = [
+            # User-specific Claude installation
+            Path.home() / ".claude" / "local" / "claude",
+            # User's global node_modules (npm install -g)
+            Path.home() / "node_modules" / ".bin" / "claude",
+            # Package installation directory node_modules
+            get_package_dir() / "node_modules" / ".bin" / "claude",
+            # Current working directory node_modules
+            Path.cwd() / "node_modules" / ".bin" / "claude",
+            # System-wide installations
+            Path("/usr/local/bin/claude"),
+            Path("/opt/homebrew/bin/claude"),
+        ]
+
+        for path in common_paths:
+            if path.exists() and path.is_file() and os.access(path, os.X_OK):
+                return str(path), False
+
+        return None, False
+
+    def get_searched_paths(self) -> list[str]:
+        """Get list of paths that would be searched for Claude CLI auto-detection."""
+        paths = []
+
+        # PATH search
+        paths.append("PATH environment variable")
+
+        # Common installation paths (in order of preference)
+        common_paths = [
+            # User-specific Claude installation
+            Path.home() / ".claude" / "local" / "claude",
+            # User's global node_modules (npm install -g)
+            Path.home() / "node_modules" / ".bin" / "claude",
+            # Package installation directory node_modules
+            get_package_dir() / "node_modules" / ".bin" / "claude",
+            # Current working directory node_modules
+            Path.cwd() / "node_modules" / ".bin" / "claude",
+            # System-wide installations
+            Path("/usr/local/bin/claude"),
+            Path("/opt/homebrew/bin/claude"),
+        ]
+
+        for path in common_paths:
+            paths.append(str(path))
+
+        return paths

ccproxy/config/cors.py

@@ -0,0 +1,79 @@
+"""CORS configuration settings."""
+
+from pydantic import BaseModel, Field, field_validator
+
+
+class CORSSettings(BaseModel):
+    """CORS-specific configuration settings."""
+
+    origins: list[str] = Field(
+        default_factory=lambda: ["*"],
+        description="CORS allowed origins",
+    )
+
+    credentials: bool = Field(
+        default=True,
+        description="CORS allow credentials",
+    )
+
+    methods: list[str] = Field(
+        default_factory=lambda: ["*"],
+        description="CORS allowed methods",
+    )
+
+    headers: list[str] = Field(
+        default_factory=lambda: ["*"],
+        description="CORS allowed headers",
+    )
+
+    origin_regex: str | None = Field(
+        default=None,
+        description="CORS origin regex pattern",
+    )
+
+    expose_headers: list[str] = Field(
+        default_factory=list,
+        description="CORS exposed headers",
+    )
+
+    max_age: int = Field(
+        default=600,
+        description="CORS preflight max age in seconds",
+        ge=0,
+    )
+
+    @field_validator("origins", mode="before")
+    @classmethod
+    def validate_cors_origins(cls, v: str | list[str]) -> list[str]:
+        """Parse CORS origins from string or list."""
+        if isinstance(v, str):
+            # Split comma-separated string
+            return [origin.strip() for origin in v.split(",") if origin.strip()]
+        return v
+
+    @field_validator("methods", mode="before")
+    @classmethod
+    def validate_cors_methods(cls, v: str | list[str]) -> list[str]:
+        """Parse CORS methods from string or list."""
+        if isinstance(v, str):
+            # Split comma-separated string
+            return [method.strip().upper() for method in v.split(",") if method.strip()]
+        return [method.upper() for method in v]
+
+    @field_validator("headers", mode="before")
+    @classmethod
+    def validate_cors_headers(cls, v: str | list[str]) -> list[str]:
+        """Parse CORS headers from string or list."""
+        if isinstance(v, str):
+            # Split comma-separated string
+            return [header.strip() for header in v.split(",") if header.strip()]
+        return v
+
+    @field_validator("expose_headers", mode="before")
+    @classmethod
+    def validate_cors_expose_headers(cls, v: str | list[str]) -> list[str]:
+        """Parse CORS expose headers from string or list."""
+        if isinstance(v, str):
+            # Split comma-separated string
+            return [header.strip() for header in v.split(",") if header.strip()]
+        return v

ccproxy/config/discovery.py

@@ -0,0 +1,87 @@
+from pathlib import Path
+from typing import Optional
+
+from ccproxy.core.system import get_xdg_config_home
+
+
+def find_toml_config_file() -> Path | None:
+    """Find the TOML configuration file for ccproxy.
+
+    Searches in the following order:
+    1. .ccproxy.toml in current directory
+    2. ccproxy.toml in git repository root (if in a git repo)
+    3. config.toml in XDG_CONFIG_HOME/ccproxy/
+    """
+    # Check current directory first
+    candidates = [
+        Path(".ccproxy.toml").resolve(),
+        Path("ccproxy.toml").resolve(),
+    ]
+
+    # Check git repo root
+    git_root = find_git_root()
+    if git_root:
+        candidates.extend(
+            [
+                git_root / ".ccproxy.toml",
+                git_root / "ccproxy.toml",
+            ]
+        )
+
+    # Check XDG config directory
+    config_dir = get_ccproxy_config_dir()
+    candidates.append(config_dir / "config.toml")
+
+    # Return first existing file
+    for candidate in candidates:
+        if candidate.exists() and candidate.is_file():
+            return candidate
+
+    return None
+
+
+def find_git_root(path: Path | None = None) -> Path | None:
+    """Find the root directory of a git repository."""
+    import subprocess
+
+    if path is None:
+        path = Path.cwd()
+
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "--show-toplevel"],
+            cwd=path,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        return Path(result.stdout.strip())
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return None
+
+
+def get_ccproxy_config_dir() -> Path:
+    """Get the ccproxy configuration directory.
+
+    Returns:
+        Path to the ccproxy configuration directory within XDG_CONFIG_HOME.
+    """
+    return get_xdg_config_home() / "ccproxy"
+
+
+def get_claude_cli_config_dir() -> Path:
+    """Get the Claude CLI configuration directory.
+
+    Returns:
+        Path to the Claude CLI configuration directory within XDG_CONFIG_HOME.
+    """
+    return get_xdg_config_home() / "claude"
+
+
+def get_claude_docker_home_dir() -> Path:
+    """Get the Claude Docker home directory.
+
+    Returns:
+        Path to the Claude Docker home directory within XDG_DATA_HOME.
+    """
+    return get_ccproxy_config_dir() / "home"