ccproxy-api 0.1.6__py3-none-any.whl → 0.2.0__py3-none-any.whl

ccproxy/cli/docker/adapter_factory.py

@@ -1,157 +0,0 @@
-"""Docker adapter factory for CLI commands.
-
-This module provides functions to create Docker adapters from CLI settings
-and command-line arguments.
-"""
-
-import getpass
-from pathlib import Path
-from typing import Any
-
-from ccproxy.config.settings import Settings
-from ccproxy.docker import (
-    DockerEnv,
-    DockerPath,
-    DockerUserContext,
-    DockerVolume,
-)
-
-
-def _create_docker_adapter_from_settings(
-    settings: Settings,
-    docker_image: str | None = None,
-    docker_env: list[str] | None = None,
-    docker_volume: list[str] | None = None,
-    docker_arg: list[str] | None = None,
-    docker_home: str | None = None,
-    docker_workspace: str | None = None,
-    user_mapping_enabled: bool | None = None,
-    user_uid: int | None = None,
-    user_gid: int | None = None,
-    command: list[str] | None = None,
-    cmd_args: list[str] | None = None,
-    **kwargs: Any,
-) -> tuple[
-    str,
-    list[DockerVolume],
-    DockerEnv,
-    list[str] | None,
-    DockerUserContext | None,
-    list[str],
-]:
-    """Convert settings and overrides to Docker adapter parameters.
-
-    Args:
-        settings: Application settings
-        docker_image: Override Docker image
-        docker_env: Additional environment variables
-        docker_volume: Additional volume mappings
-        docker_arg: Additional Docker arguments
-        docker_home: Override home directory
-        docker_workspace: Override workspace directory
-        user_mapping_enabled: Override user mapping setting
-        user_uid: Override user ID
-        user_gid: Override group ID
-        command: Command to run in container
-        cmd_args: Arguments for the command
-        **kwargs: Additional keyword arguments (ignored)
-
-    Returns:
-        Tuple of (image, volumes, environment, command, user_context, additional_args)
-    """
-    docker_settings = settings.docker
-
-    # Determine effective image
-    image = docker_image or docker_settings.docker_image
-
-    # Process volumes
-    volumes: list[DockerVolume] = []
-
-    # Add home/workspace volumes with effective directories
-    home_dir = docker_home or docker_settings.docker_home_directory
-    workspace_dir = docker_workspace or docker_settings.docker_workspace_directory
-
-    if home_dir:
-        volumes.append((str(Path(home_dir)), "/data/home"))
-    if workspace_dir:
-        volumes.append((str(Path(workspace_dir)), "/data/workspace"))
-
-    # Add base volumes from settings
-    for vol_str in docker_settings.docker_volumes:
-        parts = vol_str.split(":", 2)
-        if len(parts) >= 2:
-            volumes.append((parts[0], parts[1]))
-
-    # Add CLI override volumes
-    if docker_volume:
-        for vol_str in docker_volume:
-            parts = vol_str.split(":", 2)
-            if len(parts) >= 2:
-                volumes.append((parts[0], parts[1]))
-
-    # Process environment
-    environment: DockerEnv = docker_settings.docker_environment.copy()
-
-    # Add home/workspace environment variables
-    if home_dir:
-        environment["CLAUDE_HOME"] = "/data/home"
-    if workspace_dir:
-        environment["CLAUDE_WORKSPACE"] = "/data/workspace"
-
-    # Add CLI override environment
-    if docker_env:
-        for env_var in docker_env:
-            if "=" in env_var:
-                key, value = env_var.split("=", 1)
-                environment[key] = value
-
-    # Create user context
-    user_context = None
-    effective_mapping_enabled = (
-        user_mapping_enabled
-        if user_mapping_enabled is not None
-        else docker_settings.user_mapping_enabled
-    )
-
-    if effective_mapping_enabled:
-        effective_uid = user_uid if user_uid is not None else docker_settings.user_uid
-        effective_gid = user_gid if user_gid is not None else docker_settings.user_gid
-
-        if effective_uid is not None and effective_gid is not None:
-            # Create DockerPath instances for user context
-            home_path = None
-            workspace_path = None
-
-            if home_dir:
-                home_path = DockerPath(
-                    host_path=Path(home_dir), container_path="/data/home"
-                )
-            if workspace_dir:
-                workspace_path = DockerPath(
-                    host_path=Path(workspace_dir), container_path="/data/workspace"
-                )
-
-            # Use a default username if not available
-            username = getpass.getuser()
-
-            user_context = DockerUserContext(
-                uid=effective_uid,
-                gid=effective_gid,
-                username=username,
-                home_path=home_path,
-                workspace_path=workspace_path,
-            )
-
-    # Build command
-    final_command = None
-    if command:
-        final_command = command.copy()
-        if cmd_args:
-            final_command.extend(cmd_args)
-
-    # Additional Docker arguments
-    additional_args = docker_settings.docker_additional_args.copy()
-    if docker_arg:
-        additional_args.extend(docker_arg)
-
-    return image, volumes, environment, final_command, user_context, additional_args

ccproxy/cli/docker/params.py

@@ -1,274 +0,0 @@
-"""Shared Docker parameter definitions for Typer CLI commands.
-
-This module provides reusable Typer Option definitions for Docker-related
-parameters that are used across multiple CLI commands, eliminating duplication.
-"""
-
-from typing import Any
-
-import typer
-
-
-# Docker parameter validation functions moved here to avoid utils dependency
-
-
-def parse_docker_env(
-    ctx: typer.Context, param: typer.CallbackParam, value: list[str] | None
-) -> list[str]:
-    """Parse Docker environment variable string."""
-    if not value:
-        return []
-
-    parsed = []
-    for env_str in value:
-        if not env_str or env_str == "[]":
-            raise typer.BadParameter(
-                f"Invalid env format: {env_str}. Expected KEY=VALUE"
-            )
-        if "=" not in env_str:
-            raise typer.BadParameter(
-                f"Invalid env format: {env_str}. Expected KEY=VALUE"
-            )
-        parsed.append(env_str)
-
-    return parsed
-
-
-def parse_docker_volume(
-    ctx: typer.Context, param: typer.CallbackParam, value: list[str] | None
-) -> list[str]:
-    """Parse Docker volume string."""
-    if not value:
-        return []
-
-    # Import the validation function from config
-    from ccproxy.config.docker_settings import validate_volume_format
-
-    parsed = []
-    for volume_str in value:
-        if not volume_str:
-            continue
-        try:
-            validated_volume = validate_volume_format(volume_str)
-            parsed.append(validated_volume)
-        except ValueError as e:
-            raise typer.BadParameter(str(e)) from e
-
-    return parsed
-
-
-def validate_docker_arg(
-    ctx: typer.Context, param: typer.CallbackParam, value: list[str] | None
-) -> list[str]:
-    """Validate Docker argument."""
-    if not value:
-        return []
-
-    # Basic validation - ensure arguments don't contain dangerous patterns
-    validated = []
-    for arg in value:
-        if not arg:
-            continue
-        # Basic validation - just return the arg for now
-        validated.append(arg)
-
-    return validated
-
-
-def validate_docker_home(
-    ctx: typer.Context, param: typer.CallbackParam, value: str | None
-) -> str | None:
-    """Validate Docker home directory."""
-    if value is None:
-        return None
-
-    from ccproxy.config.docker_settings import validate_host_path
-
-    try:
-        return validate_host_path(value)
-    except ValueError as e:
-        raise typer.BadParameter(str(e)) from e
-
-
-def validate_docker_image(
-    ctx: typer.Context, param: typer.CallbackParam, value: str | None
-) -> str | None:
-    """Validate Docker image name."""
-    if value is None:
-        return None
-
-    if not value:
-        raise typer.BadParameter("Docker image cannot be empty")
-
-    # Basic validation - no spaces allowed in image names
-    if " " in value:
-        raise typer.BadParameter(f"Docker image name cannot contain spaces: {value}")
-
-    return value
-
-
-def validate_docker_workspace(
-    ctx: typer.Context, param: typer.CallbackParam, value: str | None
-) -> str | None:
-    """Validate Docker workspace directory."""
-    if value is None:
-        return None
-
-    from ccproxy.config.docker_settings import validate_host_path
-
-    try:
-        return validate_host_path(value)
-    except ValueError as e:
-        raise typer.BadParameter(str(e)) from e
-
-
-def validate_user_gid(
-    ctx: typer.Context, param: typer.CallbackParam, value: int | None
-) -> int | None:
-    """Validate user GID."""
-    if value is None:
-        return None
-
-    if value < 0:
-        raise typer.BadParameter("GID must be non-negative")
-
-    return value
-
-
-def validate_user_uid(
-    ctx: typer.Context, param: typer.CallbackParam, value: int | None
-) -> int | None:
-    """Validate user UID."""
-    if value is None:
-        return None
-
-    if value < 0:
-        raise typer.BadParameter("UID must be non-negative")
-
-    return value
-
-
-def docker_image_option() -> Any:
-    """Docker image parameter."""
-    return typer.Option(
-        None,
-        "--docker-image",
-        help="Docker image to use (overrides config)",
-    )
-
-
-def docker_env_option() -> Any:
-    """Docker environment variables parameter."""
-    return typer.Option(
-        [],
-        "--docker-env",
-        help="Environment variables to pass to Docker (KEY=VALUE format, can be used multiple times)",
-    )
-
-
-def docker_volume_option() -> Any:
-    """Docker volume mounts parameter."""
-    return typer.Option(
-        [],
-        "--docker-volume",
-        help="Volume mounts to add (host:container[:options] format, can be used multiple times)",
-    )
-
-
-def docker_arg_option() -> Any:
-    """Docker arguments parameter."""
-    return typer.Option(
-        [],
-        "--docker-arg",
-        help="Additional Docker run arguments (can be used multiple times)",
-    )
-
-
-def docker_home_option() -> Any:
-    """Docker home directory parameter."""
-    return typer.Option(
-        None,
-        "--docker-home",
-        help="Home directory inside Docker container (overrides config)",
-    )
-
-
-def docker_workspace_option() -> Any:
-    """Docker workspace directory parameter."""
-    return typer.Option(
-        None,
-        "--docker-workspace",
-        help="Workspace directory inside Docker container (overrides config)",
-    )
-
-
-def user_mapping_option() -> Any:
-    """User mapping parameter."""
-    return typer.Option(
-        None,
-        "--user-mapping/--no-user-mapping",
-        help="Enable/disable UID/GID mapping (overrides config)",
-    )
-
-
-def user_uid_option() -> Any:
-    """User UID parameter."""
-    return typer.Option(
-        None,
-        "--user-uid",
-        help="User ID to run container as (overrides config)",
-        min=0,
-    )
-
-
-def user_gid_option() -> Any:
-    """User GID parameter."""
-    return typer.Option(
-        None,
-        "--user-gid",
-        help="Group ID to run container as (overrides config)",
-        min=0,
-    )
-
-
-class DockerOptions:
-    """Container for all Docker-related Typer options.
-
-    This class provides a convenient way to include all Docker-related
-    options in a command using typed attributes.
-    """
-
-    def __init__(
-        self,
-        docker_image: str | None = None,
-        docker_env: list[str] | None = None,
-        docker_volume: list[str] | None = None,
-        docker_arg: list[str] | None = None,
-        docker_home: str | None = None,
-        docker_workspace: str | None = None,
-        user_mapping_enabled: bool | None = None,
-        user_uid: int | None = None,
-        user_gid: int | None = None,
-    ):
-        """Initialize Docker options.
-
-        Args:
-            docker_image: Docker image to use
-            docker_env: Environment variables list
-            docker_volume: Volume mounts list
-            docker_arg: Additional Docker arguments
-            docker_home: Home directory path
-            docker_workspace: Workspace directory path
-            user_mapping_enabled: User mapping flag
-            user_uid: User ID
-            user_gid: Group ID
-        """
-        self.docker_image = docker_image
-        self.docker_env = docker_env or []
-        self.docker_volume = docker_volume or []
-        self.docker_arg = docker_arg or []
-        self.docker_home = docker_home
-        self.docker_workspace = docker_workspace
-        self.user_mapping_enabled = user_mapping_enabled
-        self.user_uid = user_uid
-        self.user_gid = user_gid

ccproxy/config/auth.py

@@ -1,153 +0,0 @@
-"""Authentication and credentials configuration."""
-
-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/ccproxy/credentials.json"),
-        Path("~/.claude/.credentials.json"),
-        Path("~/.config/claude/.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