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

ccproxy/plugins/credential_balancer/plugin.py

@@ -0,0 +1,146 @@
+"""Plugin entry point for the credential balancer."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from ccproxy.core.logging import get_plugin_logger
+from ccproxy.core.plugins import (
+    PluginContext,
+    PluginManifest,
+    SystemPluginFactory,
+    SystemPluginRuntime,
+)
+from ccproxy.services.auth_registry import AuthManagerRegistry
+
+from .config import CredentialBalancerSettings
+from .hook import CredentialBalancerHook
+from .manager import CredentialBalancerTokenManager
+
+
+logger = get_plugin_logger()
+
+
+class CredentialBalancerRuntime(SystemPluginRuntime):
+    """Runtime responsible for registering auth managers and hooks."""
+
+    def __init__(self, manifest: PluginManifest):
+        super().__init__(manifest)
+        self._registrations: list[tuple[str, CredentialBalancerTokenManager]] = []
+        self._hook: CredentialBalancerHook | None = None
+        self._registry: AuthManagerRegistry | None = None
+
+    async def _on_initialize(self) -> None:
+        await super()._on_initialize()
+        if not self.context:
+            raise RuntimeError("Context not set")
+
+        config = self.context.get("config")
+        if not isinstance(config, CredentialBalancerSettings):
+            logger.debug("credential_balancer_using_default_config")
+            config = CredentialBalancerSettings()
+
+        if not config.enabled:
+            logger.info("credential_balancer_disabled")
+            return
+
+        if not config.providers:
+            logger.warning("credential_balancer_no_providers_configured")
+            return
+
+        service_container = self.context.get("service_container")
+        if not service_container:
+            raise RuntimeError("Service container unavailable for credential balancer")
+
+        registry = service_container.get_auth_manager_registry()
+        self._registry = registry
+
+        base_logger = self.context.get("logger") or get_plugin_logger(__name__)
+        managers: list[CredentialBalancerTokenManager] = []
+
+        for pool in config.providers:
+            manager_name = pool.manager_name
+            if manager_name is None:
+                raise ValueError(
+                    f"Credential balancer pool '{pool.provider}' missing manager name"
+                )
+            manager_logger = base_logger.bind(pool=manager_name)
+            # Use async factory to create manager with composed AuthManagers
+            manager = await CredentialBalancerTokenManager.create(
+                pool, logger=manager_logger
+            )
+            registry.register_instance(manager_name, manager)
+            managers.append(manager)
+            self._registrations.append((manager_name, manager))
+            logger.info(
+                "credential_balancer_manager_registered",
+                manager=manager_name,
+                provider=pool.provider,
+                strategy=pool.strategy.value,
+                credentials=len(pool.credentials),
+            )
+
+        if managers:
+            hook_registry = self.context.get("hook_registry")
+            if not hook_registry:
+                app = self.context.get("app")
+                if app and hasattr(app.state, "hook_registry"):
+                    hook_registry = app.state.hook_registry
+
+            if hook_registry:
+                hook = CredentialBalancerHook(managers)
+                hook_registry.register(hook)
+                self._hook = hook
+                logger.debug("credential_balancer_hook_registered")
+            else:
+                logger.warning("credential_balancer_hook_registry_missing")
+
+    async def _on_shutdown(self) -> None:
+        await super()._on_shutdown()
+        if self.context and self._hook:
+            hook_registry = self.context.get("hook_registry")
+            if not hook_registry:
+                app = self.context.get("app")
+                if app and hasattr(app.state, "hook_registry"):
+                    hook_registry = app.state.hook_registry
+            if hook_registry:
+                hook_registry.unregister(self._hook)
+                logger.debug("credential_balancer_hook_unregistered")
+        self._hook = None
+
+        if self._registry:
+            for name, _ in self._registrations:
+                try:
+                    self._registry.unregister(name)
+                except Exception:
+                    logger.debug(
+                        "credential_balancer_registry_unregistration_failed",
+                        manager=name,
+                    )
+        self._registrations.clear()
+
+
+class CredentialBalancerFactory(SystemPluginFactory):
+    """Factory for the credential balancer plugin."""
+
+    def __init__(self) -> None:
+        manifest = PluginManifest(
+            name="credential_balancer",
+            version="0.1.0",
+            description="Rotate across multiple credential files for upstream providers",
+            is_provider=False,
+            config_class=CredentialBalancerSettings,
+        )
+        super().__init__(manifest)
+
+    def create_runtime(self) -> CredentialBalancerRuntime:
+        return CredentialBalancerRuntime(self.manifest)
+
+    def create_context(self, core_services: Any) -> PluginContext:
+        context = super().create_context(core_services)
+        return context
+
+
+factory = CredentialBalancerFactory()
+
+__all__ = ["CredentialBalancerFactory", "CredentialBalancerRuntime", "factory"]

ccproxy/plugins/dashboard/README.md

@@ -0,0 +1,25 @@
+# Dashboard Plugin
+
+Serves the CCProxy dashboard SPA and supporting APIs.
+
+## Highlights
+- Mounts static assets for the dashboard when available on disk
+- Registers dashboard routes for health, session, and telemetry views
+- Integrates with FastAPI app mounting during plugin initialization
+
+## Configuration
+- `DashboardPluginConfig` toggles static asset mounting and route exposure
+- Defaults to auto-mounting assets under `/dashboard/assets` when present
+- Generate defaults with `python3 scripts/generate_config_from_model.py \
+  --format toml --plugin dashboard --config-class DashboardPluginConfig`
+
+```toml
+[plugins.dashboard]
+# enabled = true
+# mount_static = true
+```
+
+## Related Components
+- `plugin.py`: runtime for mounting static files
+- `routes.py`: FastAPI router for dashboard APIs
+- `config.py`: settings model for plugin toggles

ccproxy/plugins/dashboard/__init__.py

@@ -0,0 +1 @@
+"""Dashboard plugin (serves SPA and favicon; mounts assets)."""

ccproxy/plugins/dashboard/config.py

@@ -0,0 +1,8 @@
+from pydantic import BaseModel, Field
+
+
+class DashboardPluginConfig(BaseModel):
+    enabled: bool = Field(default=True, description="Enable dashboard routes")
+    mount_static: bool = Field(
+        default=True, description="Mount /dashboard/assets static files if present"
+    )

ccproxy/plugins/dashboard/plugin.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from fastapi.staticfiles import StaticFiles
+
+from ccproxy.core.logging import get_plugin_logger
+from ccproxy.core.plugins import (
+    PluginManifest,
+    RouteSpec,
+    SystemPluginFactory,
+    SystemPluginRuntime,
+)
+
+from .config import DashboardPluginConfig
+
+
+logger = get_plugin_logger()
+
+
+class DashboardRuntime(SystemPluginRuntime):
+    async def _on_initialize(self) -> None:
+        if not self.context:
+            raise RuntimeError("Context not set")
+        from typing import cast
+
+        cfg = cast(DashboardPluginConfig | None, self.context.get("config"))
+        app = self.context.get("app")
+        if not app or not hasattr(app, "mount"):
+            return
+
+        # Optionally mount static assets for the SPA
+        cfg = cfg or DashboardPluginConfig()
+        if cfg.mount_static:
+            current_file = Path(__file__)
+            project_root = current_file.parent.parent.parent
+            dashboard_static_path = project_root / "ccproxy" / "static" / "dashboard"
+            if dashboard_static_path.exists():
+                try:
+                    app.mount(
+                        "/dashboard/assets",
+                        StaticFiles(directory=str(dashboard_static_path)),
+                        name="dashboard-static",
+                    )
+                    logger.debug(
+                        "dashboard_static_files_mounted",
+                        path=str(dashboard_static_path),
+                    )
+                except Exception as e:  # pragma: no cover
+                    logger.warning("dashboard_static_mount_failed", error=str(e))
+
+
+class DashboardFactory(SystemPluginFactory):
+    def __init__(self) -> None:
+        from .routes import router as dashboard_router
+
+        manifest = PluginManifest(
+            name="dashboard",
+            version="0.1.0",
+            description="Dashboard SPA routes and static asset mounting",
+            is_provider=False,
+            config_class=DashboardPluginConfig,
+            routes=[RouteSpec(router=dashboard_router, prefix="", tags=["dashboard"])],
+        )
+        super().__init__(manifest)
+
+    def create_runtime(self) -> DashboardRuntime:
+        return DashboardRuntime(self.manifest)
+
+
+factory = DashboardFactory()

ccproxy/plugins/dashboard/routes.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from fastapi import APIRouter, HTTPException
+from fastapi.responses import FileResponse, HTMLResponse
+
+
+router = APIRouter()
+
+
+@router.get("/dashboard")
+async def get_metrics_dashboard() -> HTMLResponse:
+    current_file = Path(__file__)
+    project_root = current_file.parent.parent.parent
+    dashboard_folder = project_root / "ccproxy" / "static" / "dashboard"
+    dashboard_index = dashboard_folder / "index.html"
+
+    if not dashboard_folder.exists():
+        raise HTTPException(
+            status_code=404,
+            detail="Dashboard not found. Build it with 'cd dashboard && bun run build:prod'",
+        )
+    if not dashboard_index.exists():
+        raise HTTPException(
+            status_code=404,
+            detail="Dashboard index.html not found. Rebuild with 'cd dashboard && bun run build:prod'",
+        )
+
+    try:
+        html_content = dashboard_index.read_text(encoding="utf-8")
+        return HTMLResponse(
+            content=html_content,
+            status_code=200,
+            headers={
+                "Cache-Control": "no-cache, no-store, must-revalidate",
+                "Pragma": "no-cache",
+                "Expires": "0",
+                "Content-Type": "text/html; charset=utf-8",
+            },
+        )
+    except (OSError, PermissionError) as e:
+        raise HTTPException(
+            status_code=500, detail=f"Dashboard file access error: {str(e)}"
+        ) from e
+    except UnicodeDecodeError as e:
+        raise HTTPException(
+            status_code=500, detail=f"Dashboard file encoding error: {str(e)}"
+        ) from e
+    except Exception as e:
+        raise HTTPException(
+            status_code=500, detail=f"Failed to serve dashboard: {str(e)}"
+        ) from e
+
+
+@router.get("/dashboard/favicon.svg")
+async def get_dashboard_favicon() -> FileResponse:
+    current_file = Path(__file__)
+    project_root = current_file.parent.parent.parent
+    favicon_path = project_root / "ccproxy" / "static" / "dashboard" / "favicon.svg"
+    if not favicon_path.exists():
+        raise HTTPException(status_code=404, detail="Favicon not found")
+    return FileResponse(
+        path=str(favicon_path),
+        media_type="image/svg+xml",
+        headers={"Cache-Control": "public, max-age=3600"},
+    )

ccproxy/plugins/docker/README.md

@@ -0,0 +1,32 @@
+# Docker Plugin
+
+Provides Docker-backed execution for CCProxy via CLI extensions.
+
+## Highlights
+- Wraps requests with `DockerAdapter` to run providers inside containers
+- Extends the `ccproxy serve` CLI with Docker-specific arguments
+- Applies CLI overrides to runtime configuration before adapter startup
+
+## Configuration
+- `DockerConfig` controls image, workspace, env vars, and volume mounts
+- CLI flags override the configuration and are declared via `cli_arguments`
+- Generate defaults with `python3 scripts/generate_config_from_model.py \
+  --format toml --plugin docker --config-class DockerConfig`
+
+```toml
+[plugins.docker]
+# enabled = true
+# docker_image = "anthropics/claude-cli:latest"
+# docker_home_directory = "/home/user"
+# docker_workspace_directory = "/workspace"
+# docker_volumes = []
+# docker_environment = []
+# user_mapping_enabled = true
+# user_uid = 1000
+# user_gid = 1000
+```
+
+## Related Components
+- `adapter.py`: executor that launches Docker containers
+- `plugin.py`: runtime handling CLI context and overrides
+- `config.py`: settings model for Docker execution

ccproxy/{docker → plugins/docker}/__init__.py

@@ -10,6 +10,7 @@ This module provides a comprehensive Docker integration system with support for:
 """
 
 from .adapter import DockerAdapter, create_docker_adapter
+from .config import DockerConfig
 from .docker_path import DockerPath, DockerPathSet
 from .middleware import (
     LoggerOutputMiddleware,
@@ -44,6 +45,8 @@ __all__ = [
     "DockerPathSet",
     # User context
     "DockerUserContext",
+    # Configuration
+    "DockerConfig",
     # Type aliases
     "DockerEnv",
     "DockerPortSpec",

ccproxy/{docker → plugins/docker}/adapter.py

@@ -3,11 +3,18 @@
 import asyncio
 import os
 import shlex
+import subprocess
 from pathlib import Path
-from typing import cast
+from typing import Any, cast
 
-from structlog import get_logger
+from fastapi import Request
+from starlette.responses import Response, StreamingResponse
 
+from ccproxy.core.logging import get_plugin_logger
+from ccproxy.services.adapters.base import BaseAdapter
+from ccproxy.streaming import DeferredStreaming
+
+from .config import DockerConfig
 from .middleware import LoggerOutputMiddleware
 from .models import DockerUserContext
 from .protocol import (
@@ -25,11 +32,19 @@ from .stream_process import (
 from .validators import create_docker_error, validate_port_spec
 
 
-logger = get_logger(__name__)
+logger = get_plugin_logger(__name__)
+
+
+class DockerAdapter(BaseAdapter, DockerAdapterProtocol):
+    """Docker adapter implementing both BaseAdapter and DockerAdapterProtocol."""
 
+    def __init__(self, config: DockerConfig | None = None):
+        """Initialize Docker adapter.
 
-class DockerAdapter:
-    """Implementation of Docker adapter."""
+        Args:
+            config: Docker configuration
+        """
+        self.config = config or DockerConfig()
 
     async def _needs_sudo(self) -> bool:
         """Check if Docker requires sudo by testing docker info command."""
@@ -286,8 +301,6 @@ class DockerAdapter:
             # Note: We can't use await here since this method replaces the process
             # Use a simple check instead
             try:
-                import subprocess
-
                 subprocess.run(
                     ["docker", "info"], check=True, capture_output=True, text=True
                 )
@@ -441,7 +454,6 @@ class DockerAdapter:
 
         # Build the Docker command to check image existence
         docker_cmd = ["docker", "inspect", image_full_name]
-        cmd_str = " ".join(shlex.quote(arg) for arg in docker_cmd)
 
         try:
             # Run Docker inspect command
@@ -559,6 +571,92 @@ class DockerAdapter:
             )
             raise error from e
 
+    # Legacy methods for backward compatibility with plugin system
+
+    def build_docker_run_args(
+        self,
+        settings: Any,
+        command: list[str] | None = None,
+        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,
+    ) -> tuple[str, list[str], list[str], list[str], dict[str, Any], dict[str, Any]]:
+        """Build Docker run arguments.
+
+        Returns:
+            Tuple of (image, volumes, environment, command, user_context, metadata)
+        """
+        # Use CLI overrides or config defaults
+        image = docker_image or self.config.docker_image
+        home_dir = docker_home or str(self.config.get_effective_home_directory())
+        workspace_dir = docker_workspace or str(
+            self.config.get_effective_workspace_directory()
+        )
+
+        # Build volumes
+        volumes = [
+            f"{home_dir}:/data/home",
+            f"{workspace_dir}:/data/workspace",
+        ]
+        volumes.extend(self.config.get_all_volumes(docker_volume))
+
+        # Build environment variables
+        env_vars = [
+            "CLAUDE_HOME=/data/home",
+            "CLAUDE_WORKSPACE=/data/workspace",
+        ]
+        env_vars.extend(self.config.get_all_environment_vars(docker_env))
+
+        # User mapping
+        user_context = {}
+        if user_mapping_enabled is None:
+            user_mapping_enabled = self.config.user_mapping_enabled
+
+        if user_mapping_enabled:
+            uid = user_uid or self.config.user_uid or os.getuid()
+            gid = user_gid or self.config.user_gid or os.getgid()
+            user_context = {"uid": uid, "gid": gid}
+
+        metadata = {
+            "config": self.config,
+            "cli_overrides": {
+                "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,
+            },
+        }
+
+        return image, volumes, env_vars, command or [], user_context, metadata
+
+    async def handle_request(
+        self, request: Request
+    ) -> Response | StreamingResponse | DeferredStreaming:
+        """Handle request (not used for Docker adapter)."""
+        raise NotImplementedError("Docker adapter does not handle HTTP requests")
+
+    async def handle_streaming(
+        self, request: Request, endpoint: str, **kwargs: Any
+    ) -> StreamingResponse | DeferredStreaming:
+        """Handle streaming request (not used for Docker adapter)."""
+        raise NotImplementedError("Docker adapter does not handle streaming requests")
+
+    async def cleanup(self) -> None:
+        """Cleanup Docker adapter resources."""
+        # No persistent resources to cleanup for Docker adapter
+        pass
+
 
 def create_docker_adapter(
     image: str | None = None,
@@ -582,7 +680,7 @@ def create_docker_adapter(
 
     Example:
         >>> adapter = create_docker_adapter()
-        >>> if adapter.is_available():
-        ...     adapter.run_container("ubuntu:latest", [], {})
+        >>> if await adapter.is_available():
+        ...     await adapter.run_container("ubuntu:latest", [], {})
     """
     return DockerAdapter()

ccproxy/plugins/docker/config.py

@@ -0,0 +1,82 @@
+"""Docker plugin configuration."""
+
+from pathlib import Path
+
+from pydantic import BaseModel, Field
+
+
+class DockerConfig(BaseModel):
+    """Configuration for Docker plugin."""
+
+    enabled: bool = Field(
+        default=True,
+        description="Enable Docker functionality",
+    )
+
+    docker_image: str = Field(
+        default="anthropics/claude-cli:latest",
+        description="Docker image to use for running commands",
+    )
+
+    docker_home_directory: str | None = Field(
+        default=None,
+        description="Home directory to mount in Docker container",
+    )
+
+    docker_workspace_directory: str | None = Field(
+        default=None,
+        description="Workspace directory to mount in Docker container",
+    )
+
+    docker_volumes: list[str] = Field(
+        default_factory=list,
+        description="Additional volume mounts for Docker container",
+    )
+
+    docker_environment: list[str] = Field(
+        default_factory=list,
+        description="Environment variables to pass to Docker container",
+    )
+
+    user_mapping_enabled: bool = Field(
+        default=True,
+        description="Enable user mapping for Docker containers",
+    )
+
+    user_uid: int | None = Field(
+        default=None,
+        description="User UID for Docker user mapping",
+    )
+
+    user_gid: int | None = Field(
+        default=None,
+        description="User GID for Docker user mapping",
+    )
+
+    def get_effective_home_directory(self) -> Path:
+        """Get the effective home directory for Docker mounting."""
+        if self.docker_home_directory:
+            return Path(self.docker_home_directory)
+        return Path.home()
+
+    def get_effective_workspace_directory(self) -> Path:
+        """Get the effective workspace directory for Docker mounting."""
+        if self.docker_workspace_directory:
+            return Path(self.docker_workspace_directory)
+        return Path.cwd()
+
+    def get_all_volumes(self, additional_volumes: list[str] | None = None) -> list[str]:
+        """Get all volume mounts including defaults and additional."""
+        volumes = self.docker_volumes.copy()
+        if additional_volumes:
+            volumes.extend(additional_volumes)
+        return volumes
+
+    def get_all_environment_vars(
+        self, additional_env: list[str] | None = None
+    ) -> list[str]:
+        """Get all environment variables including defaults and additional."""
+        env_vars = self.docker_environment.copy()
+        if additional_env:
+            env_vars.extend(additional_env)
+        return env_vars

ccproxy/{docker → plugins/docker}/docker_path.py

@@ -4,10 +4,11 @@ from pathlib import Path
 from typing import Self
 
 from pydantic import BaseModel, field_validator
-from structlog import get_logger
 
+from ccproxy.core.logging import get_plugin_logger
 
-logger = get_logger(__name__)
+
+logger = get_plugin_logger(__name__)
 
 
 class DockerPath(BaseModel):
@@ -116,7 +117,7 @@ class DockerPathSet:
         """
         self.base_host_path = Path(base_host_path).resolve() if base_host_path else None
         self.paths: dict[str, DockerPath] = {}
-        self.logger = get_logger(f"{__name__}.{self.__class__.__name__}")
+        self.logger = get_plugin_logger(f"{__name__}.{self.__class__.__name__}")
 
     def add(
         self, name: str, container_path: str, host_subpath: str | None = None

ccproxy/{docker → plugins/docker}/middleware.py

@@ -2,12 +2,12 @@
 
 from typing import Any
 
-from structlog import get_logger
+from ccproxy.core.logging import get_plugin_logger
 
 from .stream_process import OutputMiddleware, create_chained_middleware
 
 
-logger = get_logger(__name__)
+logger = get_plugin_logger(__name__)
 
 
 class LoggerOutputMiddleware(OutputMiddleware[str]):