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

ccproxy/plugins/docker/plugin.py

@@ -0,0 +1,198 @@
+"""Docker plugin with CLI extensions."""
+
+from typing import Any
+
+import ccproxy.core.logging
+from ccproxy.core.plugins import (
+    BaseProviderPluginFactory,
+    PluginContext,
+    PluginManifest,
+    ProviderPluginRuntime,
+)
+from ccproxy.core.plugins.declaration import CliArgumentSpec
+
+from .adapter import DockerAdapter
+from .config import DockerConfig
+
+
+logger = ccproxy.core.logging.get_plugin_logger(__name__)
+
+
+class DockerRuntime(ProviderPluginRuntime):
+    """Runtime for Docker plugin."""
+
+    def __init__(self, manifest: PluginManifest):
+        """Initialize runtime."""
+        super().__init__(manifest)
+
+    async def _on_initialize(self) -> None:
+        """Initialize the Docker plugin."""
+        await super()._on_initialize()
+
+        if not self.context:
+            raise RuntimeError("Context not set")
+
+        # Get CLI arguments from context
+        settings = self.context.get("settings")
+        if settings:
+            cli_context = settings.get_cli_context()
+
+            # Process Docker CLI flags and update config
+            config = self.context.get("config")
+            if config and isinstance(config, DockerConfig):
+                self._apply_cli_overrides(cli_context, config)
+
+        config = self.context.get("config")
+        docker_image = (
+            config.docker_image if config and isinstance(config, DockerConfig) else None
+        )
+
+        logger.debug(
+            "plugin_initialized",
+            plugin="docker",
+            version="0.1.0",
+            status="initialized",
+            docker_image=docker_image,
+        )
+
+    def _apply_cli_overrides(
+        self, cli_context: dict[str, Any], config: DockerConfig
+    ) -> None:
+        """Apply CLI flag overrides to Docker config."""
+        # Apply CLI overrides to config
+        if cli_context.get("docker_image"):
+            config.docker_image = cli_context["docker_image"]
+
+        if cli_context.get("docker_home"):
+            config.docker_home_directory = cli_context["docker_home"]
+
+        if cli_context.get("docker_workspace"):
+            config.docker_workspace_directory = cli_context["docker_workspace"]
+
+        if cli_context.get("docker_env"):
+            config.docker_environment.extend(cli_context["docker_env"])
+
+        if cli_context.get("docker_volume"):
+            config.docker_volumes.extend(cli_context["docker_volume"])
+
+        if cli_context.get("user_mapping_enabled") is not None:
+            config.user_mapping_enabled = cli_context["user_mapping_enabled"]
+
+        if cli_context.get("user_uid"):
+            config.user_uid = cli_context["user_uid"]
+
+        if cli_context.get("user_gid"):
+            config.user_gid = cli_context["user_gid"]
+
+        logger.debug("docker_cli_overrides_applied", cli_overrides=cli_context)
+
+
+class DockerFactory(BaseProviderPluginFactory):
+    """Factory for Docker plugin."""
+
+    # Plugin configuration via class attributes
+    plugin_name = "docker"
+    plugin_description = "Docker container management for CCProxy"
+    runtime_class = DockerRuntime
+    adapter_class = DockerAdapter
+    config_class = DockerConfig
+
+    # CLI extension declarations - all Docker-related CLI arguments
+    cli_arguments = [
+        CliArgumentSpec(
+            target_command="serve",
+            argument_name="docker",
+            argument_type=bool,
+            help_text="Run using Docker instead of local execution",
+            default=False,
+            typer_kwargs={
+                "is_flag": True,
+                "flag_value": True,
+                "option": ["--docker", "-d"],
+            },
+        ),
+        CliArgumentSpec(
+            target_command="serve",
+            argument_name="docker_image",
+            argument_type=str,
+            help_text="Docker image to use (overrides configuration)",
+            typer_kwargs={"rich_help_panel": "Docker Settings"},
+        ),
+        CliArgumentSpec(
+            target_command="serve",
+            argument_name="docker_env",
+            argument_type=list[str],
+            help_text="Environment variables to pass to Docker container",
+            typer_kwargs={
+                "rich_help_panel": "Docker Settings",
+                "option": ["--docker-env", "-e"],
+            },
+        ),
+        CliArgumentSpec(
+            target_command="serve",
+            argument_name="docker_volume",
+            argument_type=list[str],
+            help_text="Volume mounts for Docker container",
+            typer_kwargs={
+                "rich_help_panel": "Docker Settings",
+                "option": ["--docker-volume", "-v"],
+            },
+        ),
+        CliArgumentSpec(
+            target_command="serve",
+            argument_name="docker_arg",
+            argument_type=list[str],
+            help_text="Additional arguments to pass to docker run",
+            typer_kwargs={"rich_help_panel": "Docker Settings"},
+        ),
+        CliArgumentSpec(
+            target_command="serve",
+            argument_name="docker_home",
+            argument_type=str,
+            help_text="Override the home directory for Docker",
+            typer_kwargs={"rich_help_panel": "Docker Settings"},
+        ),
+        CliArgumentSpec(
+            target_command="serve",
+            argument_name="docker_workspace",
+            argument_type=str,
+            help_text="Override the workspace directory for Docker",
+            typer_kwargs={"rich_help_panel": "Docker Settings"},
+        ),
+        CliArgumentSpec(
+            target_command="serve",
+            argument_name="user_mapping_enabled",
+            argument_type=bool,
+            help_text="Enable user mapping for Docker",
+            typer_kwargs={
+                "rich_help_panel": "Docker Settings",
+                "option": ["--user-mapping/--no-user-mapping"],
+            },
+        ),
+        CliArgumentSpec(
+            target_command="serve",
+            argument_name="user_uid",
+            argument_type=int,
+            help_text="User UID for Docker user mapping",
+            typer_kwargs={"rich_help_panel": "Docker Settings"},
+        ),
+        CliArgumentSpec(
+            target_command="serve",
+            argument_name="user_gid",
+            argument_type=int,
+            help_text="User GID for Docker user mapping",
+            typer_kwargs={"rich_help_panel": "Docker Settings"},
+        ),
+    ]
+
+    async def create_adapter(self, context: PluginContext) -> DockerAdapter:
+        """Create Docker adapter instance."""
+        config = context.get("config")
+        if not isinstance(config, DockerConfig):
+            config = DockerConfig()
+
+        return DockerAdapter(config=config)
+
+
+# Export factory instance
+factory = DockerFactory()

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

@@ -6,7 +6,7 @@ for real-time output handling in CLI applications.
 
 Example:
     ```python
-    from ccproxy.docker.stream_process import run_command, DefaultOutputMiddleware
+    from ccproxy.plugins.docker.stream_process import run_command, DefaultOutputMiddleware
 
     # Create custom middleware to add timestamps
     from datetime import datetime
@@ -162,8 +162,8 @@ def create_chained_middleware(
 
     Example:
         ```python
-        from ccproxy.docker.stream_process import create_chained_middleware
-        from ccproxy.docker.adapter import LoggerOutputMiddleware
+        from ccproxy.plugins.docker.stream_process import create_chained_middleware
+        from ccproxy.plugins.docker.adapter import LoggerOutputMiddleware
 
         # Create individual middleware components
         logger_middleware = LoggerOutputMiddleware(logger)

ccproxy/plugins/duckdb_storage/README.md

@@ -0,0 +1,26 @@
+# DuckDB Storage Plugin
+
+Provides DuckDB-backed storage for analytics and request logging data.
+
+## Highlights
+- Initializes a DuckDB database and exposes it via the plugin registry
+- Creates directories automatically and reuses the configured database path
+- Optionally runs VACUUM/OPTIMIZE on shutdown for compactness
+
+## Configuration
+- `DuckDBStorageConfig` toggles enablement, database path, and optimizations
+- Other plugins reference the exposed `log_storage` service by name
+- Generate defaults with `python3 scripts/generate_config_from_model.py \
+  --format toml --plugin duckdb_storage --config-class DuckDBStorageConfig`
+
+```toml
+[plugins.duckdb_storage]
+# enabled = true
+# database_path = "~/.local/share/ccproxy/metrics.duckdb"
+# optimize_on_shutdown = false
+```
+
+## Related Components
+- `plugin.py`: runtime lifecycle and service registration
+- `storage.py`: `SimpleDuckDBStorage` helper for connections
+- `routes.py`: FastAPI router under `/duckdb` for simple diagnostics

ccproxy/plugins/duckdb_storage/__init__.py

@@ -0,0 +1 @@
+"""DuckDB storage plugin package."""

ccproxy/plugins/duckdb_storage/config.py

@@ -0,0 +1,22 @@
+from pydantic import BaseModel, Field
+
+
+class DuckDBStorageConfig(BaseModel):
+    """Config for the DuckDB storage plugin.
+
+    Notes:
+    - By default this plugin mirrors core Observability settings and path.
+    - You can override the database path if needed via plugin config.
+    """
+
+    enabled: bool = Field(
+        default=True,
+        description="Enable DuckDB storage plugin",
+    )
+    database_path: str | None = Field(
+        default=None, description="Optional override for DuckDB database path"
+    )
+    optimize_on_shutdown: bool = Field(
+        default=False,
+        description="Run PRAGMA optimize on shutdown (file-backed DB only)",
+    )

ccproxy/plugins/duckdb_storage/plugin.py

@@ -0,0 +1,128 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from ccproxy.core.logging import get_plugin_logger
+from ccproxy.core.plugins import (
+    PluginManifest,
+    RouteSpec,
+    SystemPluginFactory,
+    SystemPluginRuntime,
+)
+
+from .config import DuckDBStorageConfig
+from .storage import SimpleDuckDBStorage
+
+
+logger = get_plugin_logger()
+
+
+def _default_db_path() -> str:
+    # Mirrors previous default: XDG_DATA_HOME/ccproxy/metrics.duckdb
+    import os
+
+    return str(
+        Path(os.environ.get("XDG_DATA_HOME", Path.home() / ".local" / "share"))
+        / "ccproxy"
+        / "metrics.duckdb"
+    )
+
+
+class DuckDBStorageRuntime(SystemPluginRuntime):
+    """Runtime for DuckDB storage plugin."""
+
+    def __init__(self, manifest: PluginManifest):
+        super().__init__(manifest)
+        self.config: DuckDBStorageConfig | None = None
+        self.storage: SimpleDuckDBStorage | None = None
+
+    async def _on_initialize(self) -> None:
+        if not self.context:
+            raise RuntimeError("Context not set")
+
+        # Resolve config
+        cfg = self.context.get("config")
+        if not isinstance(cfg, DuckDBStorageConfig):
+            logger.warning("plugin_no_config_using_defaults")
+            cfg = DuckDBStorageConfig()
+        self.config = cfg
+
+        # Determine if storage should be enabled: respect plugin flag and any
+        # app-wide observability needs (logs endpoints/collection) if present.
+        # Enable only if plugin config enables it
+        enabled = bool(cfg.enabled)
+        if not enabled:
+            logger.debug("duckdb_plugin_disabled", category="plugin")
+            return
+
+        # Resolve DB path
+        db_path = cfg.database_path or _default_db_path()
+        Path(db_path).parent.mkdir(parents=True, exist_ok=True)
+
+        # Initialize storage
+        self.storage = SimpleDuckDBStorage(database_path=db_path)
+        await self.storage.initialize()
+
+        # Expose storage via plugin registry and app.state
+        registry = self.context.get("plugin_registry")
+        if registry:
+            registry.register_service("log_storage", self.storage, self.manifest.name)
+            logger.debug(
+                "duckdb_storage_service_registered", path=db_path, category="plugin"
+            )
+
+        logger.info("duckdb_storage_initialized", path=db_path, category="plugin")
+
+    async def _on_shutdown(self) -> None:
+        if self.storage:
+            # Optional optimize on shutdown
+            if self.config and self.config.optimize_on_shutdown:
+                try:
+                    self.storage.optimize()
+                except Exception as e:  # pragma: no cover - best-effort
+                    logger.warning("duckdb_optimize_on_shutdown_failed", error=str(e))
+            try:
+                await self.storage.close()
+            except Exception as e:
+                logger.warning("duckdb_storage_close_error", error=str(e))
+            self.storage = None
+
+    async def _get_health_details(self) -> dict[str, Any]:
+        has_service = False
+        if self.context:
+            reg = self.context.get("plugin_registry")
+            if reg is not None:
+                try:
+                    has_service = reg.has_service("log_storage")
+                except Exception:
+                    has_service = False
+        return {
+            "type": "system",
+            "initialized": self.initialized,
+            "enabled": bool(self.storage),
+            "has_service": has_service,
+        }
+
+
+class DuckDBStorageFactory(SystemPluginFactory):
+    def __init__(self) -> None:
+        from .routes import router as duckdb_router
+
+        manifest = PluginManifest(
+            name="duckdb_storage",
+            version="0.1.0",
+            description="Provides DuckDB-backed request log storage",
+            is_provider=False,
+            provides=["log_storage"],
+            config_class=DuckDBStorageConfig,
+            routes=[RouteSpec(router=duckdb_router, prefix="/duckdb", tags=["duckdb"])],
+        )
+        super().__init__(manifest)
+
+    def create_runtime(self) -> DuckDBStorageRuntime:
+        return DuckDBStorageRuntime(self.manifest)
+
+
+# Export the factory instance for entry points
+factory = DuckDBStorageFactory()

ccproxy/plugins/duckdb_storage/routes.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+from typing import Any, cast
+
+from fastapi import APIRouter, HTTPException, Request
+
+
+router = APIRouter()
+
+
+def _get_storage(request: Request) -> Any:
+    storage = getattr(request.app.state, "log_storage", None)
+    if not storage:
+        # Backward-compat alias
+        storage = getattr(request.app.state, "duckdb_storage", None)
+    return storage
+
+
+@router.get("/health")
+async def health(request: Request) -> dict[str, Any]:
+    storage = _get_storage(request)
+    if not storage:
+        raise HTTPException(status_code=503, detail="Storage not initialized")
+    return cast(dict[str, Any], await storage.health_check())
+
+
+@router.get("/status")
+async def status(request: Request) -> dict[str, Any]:
+    storage = _get_storage(request)
+    if not storage:
+        raise HTTPException(status_code=503, detail="Storage not initialized")
+
+    health = cast(dict[str, Any], await storage.health_check())
+
+    # Include basic plugin/service context when available
+    plugin_info: dict[str, Any] = {
+        "plugin": "duckdb_storage",
+        "service_registered": False,
+    }
+
+    try:
+        if hasattr(request.app.state, "plugin_registry"):
+            registry = request.app.state.plugin_registry
+            plugin_info["service_registered"] = registry.has_service("log_storage")
+    except Exception:
+        pass
+
+    return {
+        "health": health,
+        **plugin_info,
+    }