ccproxy-api 0.1.0__py3-none-any.whl

ccproxy/cli/docker/adapter_factory.py

@@ -0,0 +1,157 @@
+"""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

@@ -0,0 +1,278 @@
+"""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 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
+
+
+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 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
+
+
+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/cli/helpers.py

@@ -0,0 +1,144 @@
+"""CLI helper utilities for CCProxy API."""
+
+import logging
+from pathlib import Path
+from typing import Any
+
+from rich_toolkit import RichToolkit, RichToolkitTheme
+from rich_toolkit.styles import TaggedStyle
+from uvicorn.logging import DefaultFormatter
+
+from ccproxy.core.async_utils import patched_typing
+
+
+def get_rich_toolkit() -> RichToolkit:
+    theme = RichToolkitTheme(
+        style=TaggedStyle(tag_width=11),
+        theme={
+            # Core tags
+            "tag.title": "white on #009485",
+            "tag": "white on #007166",
+            "placeholder": "grey85",
+            "text": "white",
+            "selected": "#007166",
+            "result": "grey85",
+            "progress": "on #007166",
+            # Status tags
+            "error": "bold red",
+            "success": "bold green",
+            "warning": "bold yellow",
+            "info": "blue",
+            # CLI specific tags
+            "version": "cyan",
+            "docker": "blue",
+            "local": "green",
+            "claude": "magenta",
+            "config": "cyan",
+            "volume": "yellow",
+            "env": "bright_blue",
+            "debug": "dim white",
+            "command": "bright_cyan",
+            # Logging
+            "log.info": "black on blue",
+            "log.error": "white on red",
+            "log.warning": "black on yellow",
+            "log.debug": "dim white",
+        },
+    )
+
+    return RichToolkit(theme=theme)
+
+
+def bold(text: str) -> str:
+    return f"[bold]{text}[/bold]"
+
+
+def dim(text: str) -> str:
+    return f"[dim]{text}[/dim]"
+
+
+def italic(text: str) -> str:
+    return f"[italic]{text}[/italic]"
+
+
+def warning(text: str) -> str:
+    return f"[yellow]{text}[/yellow]"
+
+
+def error(text: str) -> str:
+    return f"[red]{text}[/red]"
+
+
+def code(text: str) -> str:
+    return f"[cyan]{text}[/cyan]"
+
+
+def success(text: str) -> str:
+    return f"[green]{text}[/green]"
+
+
+def link(text: str, link: str) -> str:
+    return f"[link={link}]{text}[/link]"
+
+
+def merge_claude_code_options(base_options: Any, **overrides: Any) -> Any:
+    """
+    Create a new ClaudeCodeOptions instance by merging base options with overrides.
+
+    Args:
+        base_options: Base ClaudeCodeOptions instance to copy from
+        **overrides: Dictionary of option overrides
+
+    Returns:
+        New ClaudeCodeOptions instance with merged options
+    """
+    with patched_typing():
+        from claude_code_sdk import ClaudeCodeOptions
+
+    # Create a new options instance with the base values
+    options = ClaudeCodeOptions()
+
+    # Copy all attributes from base_options
+    if base_options:
+        for attr in [
+            "model",
+            "max_thinking_tokens",
+            "max_turns",
+            "cwd",
+            "system_prompt",
+            "append_system_prompt",
+            "permission_mode",
+            "permission_prompt_tool_name",
+            "continue_conversation",
+            "resume",
+            "allowed_tools",
+            "disallowed_tools",
+            "mcp_servers",
+            "mcp_tools",
+            # Anthropic API fields
+            "temperature",
+            "top_p",
+            "top_k",
+            "stop_sequences",
+            "tools",
+            "metadata",
+            "service_tier",
+        ]:
+            if hasattr(base_options, attr):
+                base_value = getattr(base_options, attr)
+                if base_value is not None:
+                    setattr(options, attr, base_value)
+
+    # Apply overrides
+    for key, value in overrides.items():
+        if value is not None and hasattr(options, key):
+            # Handle special type conversions for specific fields
+            if key == "cwd" and not isinstance(value, str):
+                value = str(value)
+            setattr(options, key, value)
+
+    return options
+
+
+def is_running_in_docker() -> bool:
+    return Path("/.dockerenv").exists()