ccproxy.cli.docker.params

ccproxy.cli.docker.params

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.

DockerOptions

DockerOptions(
    docker_image=None,
    docker_env=None,
    docker_volume=None,
    docker_arg=None,
    docker_home=None,
    docker_workspace=None,
    user_mapping_enabled=None,
    user_uid=None,
    user_gid=None,
)

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.

Parameters:

Name	Type	Description	Default
docker_image	str | None	Docker image to use	None
docker_env	list[str] | None	Environment variables list	None
docker_volume	list[str] | None	Volume mounts list	None
docker_arg	list[str] | None	Additional Docker arguments	None
docker_home	str | None	Home directory path	None
docker_workspace	str | None	Workspace directory path	None
user_mapping_enabled	bool | None	User mapping flag	None
user_uid	int | None	User ID	None
user_gid	int | None	Group ID	None

Source code in ccproxy/cli/docker/params.py

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

parse_docker_env

parse_docker_env(ctx, param, value)

Parse Docker environment variable string.

Source code in ccproxy/cli/docker/params.py

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

parse_docker_volume

parse_docker_volume(ctx, param, value)

Parse Docker volume string.

Source code in ccproxy/cli/docker/params.py

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

validate_docker_arg

validate_docker_arg(ctx, param, value)

Validate Docker argument.

Source code in ccproxy/cli/docker/params.py

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

validate_docker_home

validate_docker_home(ctx, param, value)

Validate Docker home directory.

Source code in ccproxy/cli/docker/params.py

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 pathlib import Path

    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

validate_docker_image

validate_docker_image(ctx, param, value)

Validate Docker image name.

Source code in ccproxy/cli/docker/params.py

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

validate_docker_workspace

validate_docker_workspace(ctx, param, value)

Validate Docker workspace directory.

Source code in ccproxy/cli/docker/params.py

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 pathlib import Path

    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

validate_user_gid

validate_user_gid(ctx, param, value)

Validate user GID.

Source code in ccproxy/cli/docker/params.py

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

validate_user_uid

validate_user_uid(ctx, param, value)

Validate user UID.

Source code in ccproxy/cli/docker/params.py

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

docker_image_option

docker_image_option()

Docker image parameter.

Source code in ccproxy/cli/docker/params.py

def docker_image_option() -> Any:
    """Docker image parameter."""
    return typer.Option(
        None,
        "--docker-image",
        help="Docker image to use (overrides config)",
    )

docker_env_option

docker_env_option()

Docker environment variables parameter.

Source code in ccproxy/cli/docker/params.py

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)",
    )

docker_volume_option

docker_volume_option()

Docker volume mounts parameter.

Source code in ccproxy/cli/docker/params.py

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)",
    )

docker_arg_option

docker_arg_option()

Docker arguments parameter.

Source code in ccproxy/cli/docker/params.py

def docker_arg_option() -> Any:
    """Docker arguments parameter."""
    return typer.Option(
        [],
        "--docker-arg",
        help="Additional Docker run arguments (can be used multiple times)",
    )

docker_home_option

docker_home_option()

Docker home directory parameter.

Source code in ccproxy/cli/docker/params.py

def docker_home_option() -> Any:
    """Docker home directory parameter."""
    return typer.Option(
        None,
        "--docker-home",
        help="Home directory inside Docker container (overrides config)",
    )

docker_workspace_option

docker_workspace_option()

Docker workspace directory parameter.

Source code in ccproxy/cli/docker/params.py

def docker_workspace_option() -> Any:
    """Docker workspace directory parameter."""
    return typer.Option(
        None,
        "--docker-workspace",
        help="Workspace directory inside Docker container (overrides config)",
    )

user_mapping_option

user_mapping_option()

User mapping parameter.

Source code in ccproxy/cli/docker/params.py

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)",
    )

user_uid_option

user_uid_option()

User UID parameter.

Source code in ccproxy/cli/docker/params.py

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,
    )

user_gid_option

user_gid_option()

User GID parameter.

Source code in ccproxy/cli/docker/params.py

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,
    )