ccproxy-api 0.1.7__py3-none-any.whl → 0.2.0a4__py3-none-any.whl

ccproxy/config/core.py

@@ -0,0 +1,227 @@
+"""Core configuration settings - server, HTTP, CORS, logging, and plugins."""
+
+from pathlib import Path
+from typing import Literal, cast
+
+from pydantic import BaseModel, Field, field_validator
+
+from ccproxy.core.system import get_xdg_config_home
+
+
+class ServerSettings(BaseModel):
+    """Server-specific configuration settings."""
+
+    host: str = Field(
+        default="127.0.0.1",
+        description="Server host address",
+    )
+
+    port: int = Field(
+        default=8000,
+        description="Server port number",
+        ge=1,
+        le=65535,
+    )
+
+    workers: int = Field(
+        default=1,
+        description="Number of worker processes",
+        ge=1,
+        le=32,
+    )
+
+    reload: bool = Field(
+        default=False,
+        description="Enable auto-reload for development",
+    )
+
+    bypass_mode: bool = Field(
+        default=False,
+        description="Enable bypass mode for testing (uses mock responses instead of real API calls)",
+    )
+
+
+class HTTPSettings(BaseModel):
+    """HTTP client configuration settings.
+
+    Controls how the core HTTP client handles compression and other HTTP-level settings.
+    """
+
+    compression_enabled: bool = Field(
+        default=True,
+        description="Enable compression for provider requests (Accept-Encoding header)",
+    )
+
+    accept_encoding: str = Field(
+        default="gzip, deflate",
+        description="Accept-Encoding header value when compression is enabled",
+    )
+
+
+class CORSSettings(BaseModel):
+    """CORS-specific configuration settings."""
+
+    origins: list[str] = Field(
+        default_factory=lambda: [
+            "vscode-file://vscode-app",
+            "http://localhost/*",
+            "http://localhost:*/*",
+            "http://127.0.0.1:*/*",
+            "http://127.0.0.1:/*",
+        ],
+        description="CORS allowed origins (avoid using '*' for security)",
+    )
+
+    credentials: bool = Field(
+        default=True,
+        description="CORS allow credentials",
+    )
+
+    methods: list[str] = Field(
+        default_factory=lambda: ["GET", "POST", "PUT", "DELETE", "OPTIONS"],
+        description="CORS allowed methods",
+    )
+
+    headers: list[str] = Field(
+        default_factory=lambda: [
+            "Content-Type",
+            "Authorization",
+            "Accept",
+            "Origin",
+            "X-Requested-With",
+        ],
+        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,
+    )
+
+
+# === Logging Configuration ===
+
+
+LogLevelName = Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL", "TRACE"]
+LOG_LEVEL_OPTIONS: tuple[str, ...] = (
+    "DEBUG",
+    "INFO",
+    "WARNING",
+    "ERROR",
+    "CRITICAL",
+    "TRACE",
+)
+
+LogFormatName = Literal["auto", "rich", "json", "plain"]
+LOG_FORMAT_OPTIONS: tuple[str, ...] = ("auto", "rich", "json", "plain")
+
+LOG_FORMAT_DESCRIPTION = "Logging format: 'rich', 'json', 'plain', or 'auto' (auto-selects based on environment)"
+
+
+class LoggingSettings(BaseModel):
+    """Centralized logging configuration - core app only."""
+
+    level: LogLevelName = Field(
+        default="INFO",
+        description="Logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL, TRACE)",
+    )
+
+    format: LogFormatName = Field(
+        default="auto",
+        description=LOG_FORMAT_DESCRIPTION,
+    )
+
+    file: str | None = Field(
+        default=None,
+        description="Path to JSON log file. If specified, logs will be written to this file in JSON format",
+    )
+
+    verbose_api: bool = Field(
+        default=False,
+        description="Enable verbose API request/response logging",
+    )
+
+    request_log_dir: str | None = Field(
+        default=None,
+        description="Directory to save individual request/response logs when verbose_api is enabled",
+    )
+
+    plugin_log_base_dir: str = Field(
+        default="/tmp/ccproxy",
+        description="Shared base directory for all plugin log outputs",
+    )
+
+    @field_validator("level", mode="before")
+    @classmethod
+    def validate_log_level(cls, value: LogLevelName | str) -> LogLevelName:
+        """Validate and normalize log level."""
+        if isinstance(value, str):
+            candidate = value.upper()
+        else:
+            candidate = value
+
+        if candidate not in LOG_LEVEL_OPTIONS:
+            raise ValueError(
+                f"Invalid log level: {value}. Must be one of {list(LOG_LEVEL_OPTIONS)}"
+            )
+
+        return cast(LogLevelName, candidate)
+
+    @field_validator("format", mode="before")
+    @classmethod
+    def validate_log_format(cls, value: LogFormatName | str) -> LogFormatName:
+        """Validate and normalize log format."""
+        if isinstance(value, str):
+            candidate = value.lower()
+        else:
+            candidate = value
+
+        if candidate not in LOG_FORMAT_OPTIONS:
+            raise ValueError(
+                f"Invalid log format: {value}. Must be one of {list(LOG_FORMAT_OPTIONS)}"
+            )
+
+        return cast(LogFormatName, candidate)
+
+
+def _default_plugin_directories() -> list[Path]:
+    """Default directories scanned for filesystem plugins."""
+
+    # package_plugins = Path(__file__).resolve().parent.parent.parent / "plugins"
+    # we don't include packages from ccproxy.plugins because they
+    # are using importlib.metadata entry points
+    user_plugins = get_xdg_config_home() / "ccproxy" / "plugins"
+
+    seen: set[Path] = set()
+    ordered: list[Path] = []
+    for candidate in [user_plugins]:
+        normalized = candidate.resolve()
+        if normalized in seen:
+            continue
+        seen.add(normalized)
+        ordered.append(candidate)
+    return ordered
+
+
+class PluginDiscoverySettings(BaseModel):
+    """Configuration for filesystem plugin discovery."""
+
+    directories: list[Path] = Field(
+        default_factory=_default_plugin_directories,
+        description=(
+            "Ordered directories scanned for local plugins."
+            " Defaults to the bundled ccproxy/plugins directory and"
+            " ${XDG_CONFIG_HOME}/ccproxy/plugins."
+        ),
+    )

ccproxy/config/env_generator.py

@@ -0,0 +1,232 @@
+"""Utility functions for generating environment variable configuration from Pydantic models."""
+
+import json
+import sys
+from pathlib import Path
+from typing import Any, TextIO, TypeVar
+
+from pydantic import BaseModel
+from pydantic.fields import FieldInfo
+
+
+T = TypeVar("T", bound=BaseModel)
+
+
+def is_hidden_in_example(field_info: FieldInfo) -> bool:
+    """Determine if a field should be omitted from generated example configs."""
+    if bool(field_info.exclude):
+        return True
+
+    extra = getattr(field_info, "json_schema_extra", None) or {}
+    return bool(extra.get("config_example_hidden"))
+
+
+def get_field_description(field_info: FieldInfo) -> str:
+    """Get a human-readable description from a Pydantic field."""
+    if field_info.description:
+        return field_info.description
+    return "Configuration setting"
+
+
+def format_value_for_env(value: Any) -> str:
+    """Format a configuration value for environment variable output.
+
+    Args:
+        value: The value to format
+
+    Returns:
+        String representation suitable for environment variables
+    """
+    if value is None:
+        return ""
+    elif isinstance(value, bool):
+        return "true" if value else "false"
+    elif isinstance(value, str):
+        return value
+    elif isinstance(value, int | float):
+        return str(value)
+    elif isinstance(value, list | dict):
+        # For complex types, try JSON representation
+        try:
+            return json.dumps(value)
+        except (TypeError, ValueError):
+            # If JSON serialization fails, use string representation
+            return str(value)
+    else:
+        return str(value)
+
+
+def generate_env_vars_from_model(
+    model_class: type[T],
+    prefix: str = "",
+    include_hidden: bool = False,
+) -> list[tuple[str, Any, str]]:
+    """Generate environment variable names and values from a Pydantic model.
+
+    Args:
+        model_class: The Pydantic model class to generate env vars from
+        prefix: Prefix for env var names (e.g., "SERVER" or "PLUGINS__MAX_TOKENS")
+        include_hidden: Whether to include fields marked as hidden in examples
+
+    Returns:
+        List of tuples: (env_var_name, value, description)
+    """
+    default_instance = model_class()
+    env_vars: list[tuple[str, Any, str]] = []
+
+    for field_name, field_info in model_class.model_fields.items():
+        if not include_hidden and is_hidden_in_example(field_info):
+            continue
+
+        field_value = getattr(default_instance, field_name)
+        env_var_name = (
+            f"{prefix}__{field_name.upper()}" if prefix else field_name.upper()
+        )
+        description = get_field_description(field_info)
+
+        if isinstance(field_value, BaseModel):
+            # Recursively handle nested models
+            nested_vars = generate_env_vars_from_model(
+                field_value.__class__, env_var_name, include_hidden
+            )
+            env_vars.extend(nested_vars)
+        else:
+            # Convert Path to string
+            if isinstance(field_value, Path):
+                field_value = str(field_value)
+
+            env_vars.append((env_var_name, field_value, description))
+
+    return env_vars
+
+
+def generate_env_config(
+    model_class: type[BaseModel],
+    prefix: str = "",
+    include_hidden: bool = False,
+    commented: bool = True,
+    header_comment: str | None = None,
+    export_format: bool = True,
+) -> str:
+    """Generate environment variable configuration string.
+
+    Args:
+        model_class: The Pydantic model class to generate config from
+        prefix: Prefix for env var names (e.g., "SERVER" or "PLUGINS__MAX_TOKENS")
+        include_hidden: Whether to include fields marked as hidden in examples
+        commented: Whether to comment out all settings (default True)
+        header_comment: Optional custom header comment
+        export_format: Whether to use 'export VAR=value' format (True) or 'VAR=value' (False)
+
+    Returns:
+        Environment variable configuration as a string
+    """
+    lines = []
+
+    # Write header
+    if header_comment:
+        for line in header_comment.split("\n"):
+            lines.append(f"# {line}" if line else "#")
+    else:
+        lines.append("# Environment Variable Configuration")
+        lines.append("# This file contains environment variables for the application")
+        if commented:
+            lines.append("# Uncomment and set values as needed")
+    lines.append("")
+
+    # Generate environment variables
+    env_vars = generate_env_vars_from_model(model_class, prefix, include_hidden)
+
+    comment_prefix = "# " if commented else ""
+    export_prefix = "export " if export_format else ""
+
+    for env_var_name, value, description in env_vars:
+        # Write description as comment
+        lines.append(f"# {description}")
+
+        # Format the value
+        formatted_value = format_value_for_env(value)
+
+        # Write the environment variable
+        if formatted_value:
+            # Quote values that contain spaces or special characters
+            if isinstance(value, str) and (
+                " " in value or any(c in value for c in ["$", '"', "'", "\\"])
+            ):
+                lines.append(
+                    f'{comment_prefix}{export_prefix}{env_var_name}="{formatted_value}"'
+                )
+            else:
+                lines.append(
+                    f"{comment_prefix}{export_prefix}{env_var_name}={formatted_value}"
+                )
+        else:
+            # Empty value
+            lines.append(f'{comment_prefix}{export_prefix}{env_var_name}=""')
+
+        lines.append("")
+
+    return "\n".join(lines)
+
+
+def write_env_config(
+    output: TextIO | Path | str,
+    model_class: type[BaseModel],
+    prefix: str = "",
+    include_hidden: bool = False,
+    commented: bool = True,
+    header_comment: str | None = None,
+    export_format: bool = True,
+) -> None:
+    """Write environment variable configuration directly to a stream or file.
+
+    Args:
+        output: Output destination - can be a TextIO stream (file, StringIO, stdout),
+                a Path object, or a string path to a file
+        model_class: The Pydantic model class to generate config from
+        prefix: Prefix for env var names (e.g., "SERVER" or "PLUGINS__MAX_TOKENS")
+        include_hidden: Whether to include fields marked as hidden in examples
+        commented: Whether to comment out all settings (default True)
+        header_comment: Optional custom header comment
+        export_format: Whether to use 'export VAR=value' format (default True)
+
+    Examples:
+        # Write to stdout
+        write_env_config(sys.stdout, Settings)
+
+        # Write to file
+        write_env_config("env.sh", Settings)
+        write_env_config(Path("env.sh"), Settings)
+
+        # Write to StringIO
+        buffer = StringIO()
+        write_env_config(buffer, Settings)
+        content = buffer.getvalue()
+
+        # Write with prefix for plugin
+        write_env_config(sys.stdout, MaxTokensConfig, prefix="PLUGINS__MAX_TOKENS")
+
+        # Write without export (for .env files)
+        write_env_config("env.sh", Settings, export_format=False)
+    """
+    # Generate env config string
+    env_string = generate_env_config(
+        model_class=model_class,
+        prefix=prefix,
+        include_hidden=include_hidden,
+        commented=commented,
+        header_comment=header_comment,
+        export_format=export_format,
+    )
+
+    # Determine output type and write
+    if isinstance(output, str | Path):
+        # Write to file path
+        Path(output).write_text(env_string, encoding="utf-8")
+    else:
+        # Write to stream (TextIO, stdout, StringIO, etc.)
+        output.write(env_string)
+        if output not in (sys.stdout, sys.stderr):
+            # Ensure trailing newline for files (not needed for stdout/stderr)
+            if not env_string.endswith("\n"):
+                output.write("\n")

ccproxy/config/runtime.py

@@ -0,0 +1,67 @@
+"""Runtime configuration settings - binary resolution configuration."""
+
+from pydantic import BaseModel, Field, field_validator
+
+
+# === Binary Resolution Configuration ===
+
+
+class BinarySettings(BaseModel):
+    """Binary resolution and package manager fallback settings."""
+
+    fallback_enabled: bool = Field(
+        default=True,
+        description="Enable package manager fallback when binaries are not found",
+    )
+
+    package_manager_only: bool = Field(
+        default=True,
+        description="Skip direct binary lookup and use package managers exclusively",
+    )
+
+    preferred_package_manager: str | None = Field(
+        default=None,
+        description="Preferred package manager (bunx, pnpm, npx). If not set, auto-detects based on availability",
+    )
+
+    package_manager_priority: list[str] = Field(
+        default_factory=lambda: ["bunx", "pnpm", "npx"],
+        description="Priority order for trying package managers when preferred is not set",
+    )
+
+    cache_results: bool = Field(
+        default=True,
+        description="Cache binary resolution results to avoid repeated lookups",
+    )
+
+    @field_validator("preferred_package_manager")
+    @classmethod
+    def validate_preferred_package_manager(cls, v: str | None) -> str | None:
+        """Validate preferred package manager."""
+        if v is not None:
+            valid_managers = ["bunx", "pnpm", "npx"]
+            if v not in valid_managers:
+                raise ValueError(
+                    f"Invalid package manager: {v}. Must be one of {valid_managers}"
+                )
+        return v
+
+    @field_validator("package_manager_priority")
+    @classmethod
+    def validate_package_manager_priority(cls, v: list[str]) -> list[str]:
+        """Validate package manager priority list."""
+        valid_managers = {"bunx", "pnpm", "npx"}
+        for manager in v:
+            if manager not in valid_managers:
+                raise ValueError(
+                    f"Invalid package manager in priority list: {manager}. "
+                    f"Must be one of {valid_managers}"
+                )
+        # Remove duplicates while preserving order
+        seen = set()
+        result = []
+        for manager in v:
+            if manager not in seen:
+                seen.add(manager)
+                result.append(manager)
+        return result

ccproxy/config/security.py

@@ -1,16 +1,49 @@
-"""Security configuration settings."""
+"""Security and authentication configuration settings."""
 
-from pydantic import BaseModel, Field
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict, Field, SecretStr, field_validator
+
+
+# === Authentication Configuration ===
+
+
+class AuthSettings(BaseModel):
+    """Configuration for authentication behavior and caching."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    credentials_ttl_seconds: float = Field(
+        3600.0,
+        description=(
+            "Cache duration for loaded credentials before rechecking storage. "
+            "Use nested env var AUTH__CREDENTIALS_TTL_SECONDS to override."
+        ),
+        ge=0.0,
+    )
+
+
+# === Security Configuration ===
 
 
 class SecuritySettings(BaseModel):
     """Security-specific configuration settings."""
 
-    auth_token: str | None = Field(
+    auth_token: SecretStr | None = Field(
         default=None,
         description="Bearer token for API authentication (optional)",
     )
 
+    @field_validator("auth_token", mode="before")
+    @classmethod
+    def validate_auth_token(cls, v: Any) -> Any:
+        """Convert string values to SecretStr."""
+        if v is None:
+            return None
+        if isinstance(v, str):
+            return SecretStr(v)
+        return v
+
     confirmation_timeout_seconds: int = Field(
         default=30,
         ge=5,