ccproxy-api 0.1.0__py3-none-any.whl

ccproxy/cli/commands/serve.py

@@ -0,0 +1,630 @@
+"""Serve command for CCProxy API server - consolidates server-related commands."""
+
+import json
+import os
+from pathlib import Path
+from typing import Any
+
+import typer
+import uvicorn
+from click import get_current_context
+from structlog import get_logger
+
+from ccproxy._version import __version__
+from ccproxy.cli.helpers import (
+    get_rich_toolkit,
+    is_running_in_docker,
+    warning,
+)
+from ccproxy.config.settings import (
+    ConfigurationError,
+    Settings,
+    config_manager,
+)
+from ccproxy.core.async_utils import get_root_package_name
+from ccproxy.docker import (
+    DockerEnv,
+    DockerPath,
+    DockerUserContext,
+    DockerVolume,
+    create_docker_adapter,
+)
+
+from ..docker import (
+    _create_docker_adapter_from_settings,
+)
+from ..docker.params import (
+    docker_arg_option,
+    docker_env_option,
+    docker_home_option,
+    docker_image_option,
+    docker_volume_option,
+    docker_workspace_option,
+    user_gid_option,
+    user_mapping_option,
+    user_uid_option,
+)
+from ..options.claude_options import (
+    ClaudeOptions,
+    allowed_tools_option,
+    append_system_prompt_option,
+    claude_cli_path_option,
+    cwd_option,
+    disallowed_tools_option,
+    max_thinking_tokens_option,
+    max_turns_option,
+    permission_mode_option,
+    permission_prompt_tool_name_option,
+)
+from ..options.core_options import CoreOptions, config_option
+from ..options.security_options import SecurityOptions, auth_token_option
+from ..options.server_options import (
+    ServerOptions,
+    host_option,
+    log_file_option,
+    log_level_option,
+    port_option,
+    reload_option,
+)
+
+
+# Logger will be configured by configuration manager
+logger = get_logger(__name__)
+
+
+def get_config_path_from_context() -> Path | None:
+    """Get config path from typer context if available."""
+    try:
+        ctx = get_current_context()
+        if ctx and ctx.obj and "config_path" in ctx.obj:
+            config_path = ctx.obj["config_path"]
+            return config_path if config_path is None else Path(config_path)
+    except RuntimeError:
+        # No active click context (e.g., in tests)
+        pass
+    return None
+
+
+def _show_api_usage_info(toolkit: Any, settings: Settings) -> None:
+    """Show API usage information when auth token is configured."""
+    from rich.console import Console
+    from rich.syntax import Syntax
+
+    toolkit.print_title("API Client Configuration", tag="config")
+
+    # Determine the base URLs
+    anthropic_base_url = f"http://{settings.server.host}:{settings.server.port}"
+    openai_base_url = f"http://{settings.server.host}:{settings.server.port}/openai"
+
+    # Show environment variable exports using code blocks
+    toolkit.print("Environment Variables for API Clients:", tag="info")
+    toolkit.print_line()
+
+    # Use rich console for code blocks
+    console = Console()
+
+    exports = f"""export ANTHROPIC_API_KEY={settings.security.auth_token}
+export ANTHROPIC_BASE_URL={anthropic_base_url}
+export OPENAI_API_KEY={settings.security.auth_token}
+export OPENAI_BASE_URL={openai_base_url}"""
+
+    console.print(Syntax(exports, "bash", theme="monokai", background_color="default"))
+    toolkit.print_line()
+
+
+def _run_docker_server(
+    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,
+) -> None:
+    """Run the server using Docker."""
+    toolkit = get_rich_toolkit()
+    logger = get_logger(__name__)
+
+    docker_env = docker_env or []
+    docker_volume = docker_volume or []
+    docker_arg = docker_arg or []
+
+    docker_env_dict = {}
+    for env_var in docker_env:
+        if "=" in env_var:
+            key, value = env_var.split("=", 1)
+            docker_env_dict[key] = value
+
+    # Add server configuration to Docker environment
+    if settings.server.reload:
+        docker_env_dict["RELOAD"] = "true"
+    docker_env_dict["PORT"] = str(settings.server.port)
+    docker_env_dict["HOST"] = "0.0.0.0"
+
+    # Display startup information
+    # toolkit.print_title(
+    #     "Starting CCProxy API server with Docker", tag="docker"
+    # )
+    # toolkit.print(
+    #     f"Server will be available at: http://{settings.server.host}:{settings.server.port}",
+    #     tag="info",
+    # )
+    toolkit.print_line()
+
+    # Show Docker configuration summary
+    toolkit.print_title("Docker Configuration Summary", tag="config")
+
+    # Determine effective directories for volume mapping
+    home_dir = docker_home or settings.docker.docker_home_directory
+    workspace_dir = docker_workspace or settings.docker.docker_workspace_directory
+
+    # Show volume information
+    toolkit.print("Volumes:", tag="config")
+    if home_dir:
+        toolkit.print(f"  Home: {home_dir} → /data/home", tag="volume")
+    if workspace_dir:
+        toolkit.print(f"  Workspace: {workspace_dir} → /data/workspace", tag="volume")
+    if docker_volume:
+        for vol in docker_volume:
+            toolkit.print(f"  Additional: {vol}", tag="volume")
+    toolkit.print_line()
+
+    # Show environment information
+    toolkit.print("Environment Variables:", tag="config")
+    key_env_vars = {
+        "CLAUDE_HOME": "/data/home",
+        "CLAUDE_WORKSPACE": "/data/workspace",
+        "PORT": str(settings.server.port),
+        "HOST": "0.0.0.0",
+    }
+    if settings.server.reload:
+        key_env_vars["RELOAD"] = "true"
+
+    for key, value in key_env_vars.items():
+        toolkit.print(f"  {key}={value}", tag="env")
+
+    # Show additional environment variables from CLI
+    for env_var in docker_env:
+        toolkit.print(f"  {env_var}", tag="env")
+
+    # Show debug environment information if log level is DEBUG
+    if settings.server.log_level == "DEBUG":
+        toolkit.print_line()
+        toolkit.print_title("Debug: All Environment Variables", tag="debug")
+        all_env = {**docker_env_dict}
+        for key, value in sorted(all_env.items()):
+            toolkit.print(f"  {key}={value}", tag="debug")
+
+    toolkit.print_line()
+
+    toolkit.print_line()
+
+    # Show API usage information if auth token is configured
+    if settings.security.auth_token:
+        _show_api_usage_info(toolkit, settings)
+
+    # Execute using the new Docker adapter
+    image, volumes, environment, command, user_context, additional_args = (
+        _create_docker_adapter_from_settings(
+            settings,
+            command=["ccproxy", "serve"],
+            docker_image=docker_image,
+            docker_env=[f"{k}={v}" for k, v in docker_env_dict.items()],
+            docker_volume=docker_volume,
+            docker_arg=docker_arg,
+            docker_home=docker_home,
+            docker_workspace=docker_workspace,
+            user_mapping_enabled=user_mapping_enabled,
+            user_uid=user_uid,
+            user_gid=user_gid,
+        )
+    )
+
+    logger.info(
+        "docker_server_config",
+        configured_image=settings.docker.docker_image,
+        effective_image=image,
+    )
+
+    # Add port mapping
+    ports = [f"{settings.server.port}:{settings.server.port}"]
+
+    # Create Docker adapter and execute
+    adapter = create_docker_adapter()
+    adapter.exec_container(
+        image=image,
+        volumes=volumes,
+        environment=environment,
+        command=command,
+        user_context=user_context,
+        ports=ports,
+    )
+
+
+def _run_local_server(settings: Settings, cli_overrides: dict[str, Any]) -> None:
+    """Run the server locally."""
+    in_docker = is_running_in_docker()
+    toolkit = get_rich_toolkit()
+    logger = get_logger(__name__)
+
+    if in_docker:
+        toolkit.print_title(
+            f"Starting CCProxy API server in {warning('docker')}",
+            tag="docker",
+        )
+        toolkit.print(
+            f"uid={warning(str(os.getuid()))} gid={warning(str(os.getgid()))}"
+        )
+        toolkit.print(f"HOME={os.environ['HOME']}")
+    # else:
+    #     toolkit.print_title("Starting CCProxy API server", tag="local")
+
+    # toolkit.print(
+    #     f"Server will be available at: http://{settings.server.host}:{settings.server.port}",
+    #     tag="info",
+    # )
+
+    # toolkit.print_line()
+
+    # Show API usage information if auth token is configured
+    if settings.security.auth_token:
+        _show_api_usage_info(toolkit, settings)
+
+    # Set environment variables for server to access CLI overrides
+    if cli_overrides:
+        os.environ["CCPROXY_CONFIG_OVERRIDES"] = json.dumps(cli_overrides)
+
+    logger.debug(
+        "server_starting",
+        host=settings.server.host,
+        port=settings.server.port,
+        url=f"http://{settings.server.host}:{settings.server.port}",
+    )
+
+    reload_includes = None
+    if settings.server.reload:
+        reload_includes = ["ccproxy", "pyproject.toml", "uv.lock"]
+
+    # Run uvicorn with our already configured logging
+    uvicorn.run(
+        app=f"{get_root_package_name()}.api.app:create_app",
+        factory=True,
+        host=settings.server.host,
+        port=settings.server.port,
+        reload=settings.server.reload,
+        workers=None,  # ,settings.workers,
+        log_config=None,
+        access_log=False,  # Disable uvicorn's default access logs
+        server_header=False,  # Disable uvicorn's server header to preserve upstream headers
+        reload_includes=reload_includes,
+        # log_config=get_uvicorn_log_config(),
+    )
+
+
+def api(
+    # Configuration
+    config: Path | None = config_option(),
+    # Server options
+    port: int | None = port_option(),
+    host: str | None = host_option(),
+    reload: bool | None = reload_option(),
+    log_level: str | None = log_level_option(),
+    log_file: str | None = log_file_option(),
+    # Security options
+    auth_token: str | None = auth_token_option(),
+    # Claude options
+    max_thinking_tokens: int | None = max_thinking_tokens_option(),
+    allowed_tools: str | None = allowed_tools_option(),
+    disallowed_tools: str | None = disallowed_tools_option(),
+    claude_cli_path: str | None = claude_cli_path_option(),
+    append_system_prompt: str | None = append_system_prompt_option(),
+    permission_mode: str | None = permission_mode_option(),
+    max_turns: int | None = max_turns_option(),
+    cwd: str | None = cwd_option(),
+    permission_prompt_tool_name: str | None = permission_prompt_tool_name_option(),
+    # Core settings
+    docker: bool = typer.Option(
+        False,
+        "--docker",
+        "-d",
+        help="Run API server using Docker instead of local execution",
+    ),
+    # Docker settings using shared parameters
+    docker_image: str | None = docker_image_option(),
+    docker_env: list[str] = docker_env_option(),
+    docker_volume: list[str] = docker_volume_option(),
+    docker_arg: list[str] = docker_arg_option(),
+    docker_home: str | None = docker_home_option(),
+    docker_workspace: str | None = docker_workspace_option(),
+    user_mapping_enabled: bool | None = user_mapping_option(),
+    user_uid: int | None = user_uid_option(),
+    user_gid: int | None = user_gid_option(),
+) -> None:
+    """
+    Start the CCProxy API server.
+
+    This command starts the API server either locally or in Docker.
+    The server provides both Anthropic and OpenAI-compatible endpoints.
+
+    All configuration options can be provided via CLI parameters,
+    which override values from configuration files and environment variables.
+
+    Examples:
+        ccproxy serve
+        ccproxy serve --port 8080 --reload
+        ccproxy serve --docker
+        ccproxy serve --docker --docker-image custom:latest --port 8080
+        ccproxy serve --max-thinking-tokens 10000 --allowed-tools Read,Write,Bash
+        ccproxy serve --port 8080 --workers 4
+    """
+    try:
+        # Early logging - use basic print until logging is configured
+        # We'll log this properly after logging is configured
+
+        # Get config path from context if not provided directly
+        if config is None:
+            config = get_config_path_from_context()
+
+        # Create option containers for better organization
+        server_options = ServerOptions(
+            port=port,
+            host=host,
+            reload=reload,
+            log_level=log_level,
+            log_file=log_file,
+        )
+
+        claude_options = ClaudeOptions(
+            max_thinking_tokens=max_thinking_tokens,
+            allowed_tools=allowed_tools,
+            disallowed_tools=disallowed_tools,
+            claude_cli_path=claude_cli_path,
+            append_system_prompt=append_system_prompt,
+            permission_mode=permission_mode,
+            max_turns=max_turns,
+            cwd=cwd,
+            permission_prompt_tool_name=permission_prompt_tool_name,
+        )
+
+        security_options = SecurityOptions(auth_token=auth_token)
+
+        # Extract CLI overrides from structured option containers
+        cli_overrides = config_manager.get_cli_overrides_from_args(
+            # Server options
+            host=server_options.host,
+            port=server_options.port,
+            reload=server_options.reload,
+            log_level=server_options.log_level,
+            log_file=server_options.log_file,
+            # Security options
+            auth_token=security_options.auth_token,
+            # Claude options
+            claude_cli_path=claude_options.claude_cli_path,
+            max_thinking_tokens=claude_options.max_thinking_tokens,
+            allowed_tools=claude_options.allowed_tools,
+            disallowed_tools=claude_options.disallowed_tools,
+            append_system_prompt=claude_options.append_system_prompt,
+            permission_mode=claude_options.permission_mode,
+            max_turns=claude_options.max_turns,
+            permission_prompt_tool_name=claude_options.permission_prompt_tool_name,
+            cwd=claude_options.cwd,
+        )
+
+        # Load settings with CLI overrides
+        settings = config_manager.load_settings(
+            config_path=config, cli_overrides=cli_overrides
+        )
+
+        # Set up logging once with the effective log level
+        # Import here to avoid circular import
+        import structlog
+
+        from ccproxy.core.logging import setup_logging
+
+        # Always reconfigure logging to ensure log level changes are picked up
+        # Use JSON logs if explicitly requested via env var
+        json_logs = os.environ.get("CCPROXY_JSON_LOGS", "").lower() == "true"
+        setup_logging(
+            json_logs=json_logs,
+            log_level=server_options.log_level or settings.server.log_level,
+            log_file=server_options.log_file or settings.server.log_file,
+        )
+
+        # Re-get logger after logging is configured
+        logger = get_logger(__name__)
+
+        # Test debug logging
+        logger.debug(
+            "Debug logging is enabled",
+            effective_log_level=server_options.log_level or settings.server.log_level,
+        )
+
+        # Log CLI command that was deferred
+        logger.info(
+            "cli_command_starting",
+            command="serve",
+            docker=docker,
+            port=server_options.port,
+            host=server_options.host,
+            config_path=str(config) if config else None,
+        )
+
+        # Log effective configuration
+        logger.info(
+            "configuration_loaded",
+            host=settings.server.host,
+            port=settings.server.port,
+            log_level=settings.server.log_level,
+            log_file=settings.server.log_file,
+            docker_mode=docker,
+            docker_image=settings.docker.docker_image if docker else None,
+            auth_enabled=bool(settings.security.auth_token),
+            duckdb_enabled=settings.observability.duckdb_enabled,
+            duckdb_path=settings.observability.duckdb_path
+            if settings.observability.duckdb_enabled
+            else None,
+            claude_cli_path=settings.claude.cli_path,
+        )
+
+        if docker:
+            _run_docker_server(
+                settings,
+                docker_image=docker_image,
+                docker_env=docker_env,
+                docker_volume=docker_volume,
+                docker_arg=docker_arg,
+                docker_home=docker_home,
+                docker_workspace=docker_workspace,
+                user_mapping_enabled=user_mapping_enabled,
+                user_uid=user_uid,
+                user_gid=user_gid,
+            )
+        else:
+            _run_local_server(settings, cli_overrides)
+
+    except ConfigurationError as e:
+        toolkit = get_rich_toolkit()
+        toolkit.print(f"Configuration error: {e}", tag="error")
+        raise typer.Exit(1) from e
+    except Exception as e:
+        toolkit = get_rich_toolkit()
+        toolkit.print(f"Error starting server: {e}", tag="error")
+        raise typer.Exit(1) from e
+
+
+def claude(
+    args: list[str] | None = typer.Argument(
+        default=None,
+        help="Arguments to pass to claude CLI (e.g. --version, doctor, config)",
+    ),
+    docker: bool = typer.Option(
+        False,
+        "--docker",
+        "-d",
+        help="Run claude command from docker image instead of local CLI",
+    ),
+    # Docker settings using shared parameters
+    docker_image: str | None = docker_image_option(),
+    docker_env: list[str] = docker_env_option(),
+    docker_volume: list[str] = docker_volume_option(),
+    docker_arg: list[str] = docker_arg_option(),
+    docker_home: str | None = docker_home_option(),
+    docker_workspace: str | None = docker_workspace_option(),
+    user_mapping_enabled: bool | None = user_mapping_option(),
+    user_uid: int | None = user_uid_option(),
+    user_gid: int | None = user_gid_option(),
+) -> None:
+    """
+    Execute claude CLI commands directly.
+
+    This is a simple pass-through to the claude CLI executable
+    found by the settings system or run from docker image.
+
+    Examples:
+        ccproxy claude -- --version
+        ccproxy claude -- doctor
+        ccproxy claude -- config
+        ccproxy claude --docker -- --version
+        ccproxy claude --docker --docker-image custom:latest -- --version
+        ccproxy claude --docker --docker-env API_KEY=sk-... --docker-volume ./data:/data -- chat
+    """
+    # Handle None args case
+    if args is None:
+        args = []
+
+    toolkit = get_rich_toolkit()
+
+    try:
+        # Log CLI command execution start
+        logger.info(
+            "cli_command_starting",
+            command="claude",
+            docker=docker,
+            args=args if args else [],
+        )
+
+        # Load settings using configuration manager
+        settings = config_manager.load_settings(
+            config_path=get_config_path_from_context()
+        )
+
+        if docker:
+            # Prepare Docker execution using new adapter
+
+            toolkit.print_title(f"image {settings.docker.docker_image}", tag="docker")
+            image, volumes, environment, command, user_context, additional_args = (
+                _create_docker_adapter_from_settings(
+                    settings,
+                    docker_image=docker_image,
+                    docker_env=docker_env,
+                    docker_volume=docker_volume,
+                    docker_arg=docker_arg,
+                    docker_home=docker_home,
+                    docker_workspace=docker_workspace,
+                    user_mapping_enabled=user_mapping_enabled,
+                    user_uid=user_uid,
+                    user_gid=user_gid,
+                    command=["claude"],
+                    cmd_args=args,
+                )
+            )
+
+            cmd_str = " ".join(command or [])
+            logger.info(
+                "docker_execution",
+                image=image,
+                command=" ".join(command or []),
+                volumes_count=len(volumes),
+                env_vars_count=len(environment),
+            )
+            toolkit.print(f"Executing: docker run ... {image} {cmd_str}", tag="docker")
+            toolkit.print_line()
+
+            # Execute using the new Docker adapter
+            adapter = create_docker_adapter()
+            adapter.exec_container(
+                image=image,
+                volumes=volumes,
+                environment=environment,
+                command=command,
+                user_context=user_context,
+            )
+        else:
+            # Get claude path from settings
+            claude_path = settings.claude.cli_path
+            if not claude_path:
+                toolkit.print("Error: Claude CLI not found.", tag="error")
+                toolkit.print(
+                    "Please install Claude CLI or configure claude_cli_path.",
+                    tag="error",
+                )
+                raise typer.Exit(1)
+
+            # Resolve to absolute path
+            if not Path(claude_path).is_absolute():
+                claude_path = str(Path(claude_path).resolve())
+
+            logger.info("local_claude_execution", claude_path=claude_path, args=args)
+            toolkit.print(f"Executing: {claude_path} {' '.join(args)}", tag="claude")
+            toolkit.print_line()
+
+            # Execute command directly
+            try:
+                # Use os.execvp to replace current process with claude
+                # This hands over full control to claude, including signal handling
+                os.execvp(claude_path, [claude_path] + args)
+            except OSError as e:
+                toolkit.print(f"Failed to execute command: {e}", tag="error")
+                raise typer.Exit(1) from e
+
+    except ConfigurationError as e:
+        logger.error("cli_configuration_error", error=str(e), command="claude")
+        toolkit.print(f"Configuration error: {e}", tag="error")
+        raise typer.Exit(1) from e
+    except Exception as e:
+        logger.error("cli_unexpected_error", error=str(e), command="claude")
+        toolkit.print(f"Error executing claude command: {e}", tag="error")
+        raise typer.Exit(1) from e

ccproxy/cli/docker/__init__.py

@@ -0,0 +1,34 @@
+"""Docker-related CLI utilities for Claude Code Proxy."""
+
+from ccproxy.cli.docker.adapter_factory import (
+    _create_docker_adapter_from_settings,
+)
+from ccproxy.cli.docker.params import (
+    DockerOptions,
+    docker_arg_option,
+    docker_env_option,
+    docker_home_option,
+    docker_image_option,
+    docker_volume_option,
+    docker_workspace_option,
+    user_gid_option,
+    user_mapping_option,
+    user_uid_option,
+)
+
+
+__all__ = [
+    # Factory functions
+    "_create_docker_adapter_from_settings",
+    # Docker options
+    "DockerOptions",
+    "docker_image_option",
+    "docker_env_option",
+    "docker_volume_option",
+    "docker_arg_option",
+    "docker_home_option",
+    "docker_workspace_option",
+    "user_mapping_option",
+    "user_uid_option",
+    "user_gid_option",
+]