ccproxy-api 0.1.6__py3-none-any.whl → 0.2.0__py3-none-any.whl

ccproxy/api/routes/plugins.py

@@ -0,0 +1,277 @@
+"""Plugin management API endpoints."""
+
+from typing import Any
+
+from fastapi import APIRouter, HTTPException, Request
+from pydantic import BaseModel
+from starlette import status
+
+import ccproxy.core.logging
+from ccproxy.auth.dependencies import ConditionalAuthDep
+
+
+logger = ccproxy.core.logging.get_logger(__name__)
+
+
+router = APIRouter(prefix="/plugins", tags=["plugins"])
+
+
+class PluginInfo(BaseModel):
+    """Plugin information model."""
+
+    name: str
+    type: str  # "builtin" or "plugin"
+    status: str  # "active", "inactive", "error"
+    version: str | None = None
+
+
+class PluginListResponse(BaseModel):
+    """Response model for plugin list."""
+
+    plugins: list[PluginInfo]
+    total: int
+
+
+class PluginStatusEntry(BaseModel):
+    name: str
+    version: str | None = None
+    type: str  # "provider" or "system"
+    provides: list[str] = []
+    requires: list[str] = []
+    optional_requires: list[str] = []
+    initialized: bool
+
+
+class PluginStatusResponse(BaseModel):
+    initialization_order: list[str]
+    services: dict[str, str]  # service_name -> provider plugin
+    plugins: list[PluginStatusEntry]
+
+
+class PluginHealthResponse(BaseModel):
+    """Response model for plugin health check."""
+
+    plugin: str
+    status: str  # "healthy", "unhealthy", "unknown"
+    adapter_loaded: bool
+    details: dict[str, Any] | None = None
+
+
+# Only core plugin management endpoints are exposed:
+# - GET /plugins: list loaded plugins
+# - GET /plugins/{plugin_name}/health: check plugin health if provided by runtime
+# - GET /plugins/status: summarize manifests and initialization state
+#
+# Dynamic reload/discover/unregister are not supported in v2 and have been removed.
+
+
+# Plugin registry is accessed directly from app state
+
+
+@router.get("", response_model=PluginListResponse)
+async def list_plugins(
+    request: Request,
+    auth: ConditionalAuthDep = None,
+) -> PluginListResponse:
+    """List all loaded plugins and built-in providers.
+
+    Returns:
+        List of all available plugins and providers
+    """
+    plugins: list[PluginInfo] = []
+
+    # Access v2 plugin registry from app state
+    if hasattr(request.app.state, "plugin_registry"):
+        from ccproxy.core.plugins import PluginRegistry
+
+        registry: PluginRegistry = request.app.state.plugin_registry
+
+        for name in registry.list_plugins():
+            factory = registry.get_factory(name)
+            if factory:
+                from ccproxy.core.plugins import factory_type_name
+
+                manifest = factory.get_manifest()
+                plugin_type = factory_type_name(factory)
+
+                plugins.append(
+                    PluginInfo(
+                        name=name,
+                        type=plugin_type,
+                        status="active",
+                        version=manifest.version,
+                    )
+                )
+
+    return PluginListResponse(plugins=plugins, total=len(plugins))
+
+
+@router.get("/{plugin_name}/health", response_model=PluginHealthResponse)
+async def plugin_health(
+    plugin_name: str,
+    request: Request,
+    auth: ConditionalAuthDep = None,
+) -> PluginHealthResponse:
+    """Check the health status of a specific plugin.
+
+    Args:
+        plugin_name: Name of the plugin to check
+
+    Returns:
+        Health status of the plugin
+
+    Raises:
+        HTTPException: If plugin not found
+    """
+    # Access v2 plugin registry from app state
+    if not hasattr(request.app.state, "plugin_registry"):
+        raise HTTPException(status_code=503, detail="Plugin registry not initialized")
+
+    from ccproxy.core.plugins import PluginRegistry
+
+    registry: PluginRegistry = request.app.state.plugin_registry
+
+    # Check if plugin exists
+    if plugin_name not in registry.list_plugins():
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Plugin '{plugin_name}' not found",
+        )
+
+    # Get the plugin runtime instance
+    runtime = registry.get_runtime(plugin_name)
+    if runtime and hasattr(runtime, "health_check"):
+        try:
+            health_result = await runtime.health_check()
+            # Convert HealthCheckResult to PluginHealthResponse
+            # Handle both dict and object response
+            if isinstance(health_result, dict):
+                status_value = health_result.get("status", "unknown")
+                output_value = health_result.get("output")
+                version_value = health_result.get("version")
+                details_value = health_result.get("details")
+            else:
+                # Access attributes for non-dict responses
+                status_value = getattr(health_result, "status", "unknown")
+                output_value = getattr(health_result, "output", None)
+                version_value = getattr(health_result, "version", None)
+                details_value = getattr(health_result, "details", None)
+
+            return PluginHealthResponse(
+                plugin=plugin_name,
+                status="healthy"
+                if status_value == "pass"
+                else "unhealthy"
+                if status_value == "fail"
+                else "unknown",
+                adapter_loaded=True,
+                details={
+                    "type": "plugin",
+                    "active": True,
+                    "health_check": {
+                        "status": status_value,
+                        "output": output_value,
+                        "version": version_value,
+                        "details": details_value,
+                    },
+                },
+            )
+        except (OSError, PermissionError) as e:
+            logger.error(
+                "plugin_health_check_io_failed",
+                plugin=plugin_name,
+                error=str(e),
+                exc_info=e,
+            )
+            return PluginHealthResponse(
+                plugin=plugin_name,
+                status="unhealthy",
+                adapter_loaded=True,
+                details={"type": "plugin", "active": True, "io_error": str(e)},
+            )
+        except Exception as e:
+            logger.error(
+                "plugin_health_check_failed",
+                plugin=plugin_name,
+                error=str(e),
+                exc_info=e,
+            )
+            return PluginHealthResponse(
+                plugin=plugin_name,
+                status="unhealthy",
+                adapter_loaded=True,
+                details={"type": "plugin", "active": True, "error": str(e)},
+            )
+    else:
+        # Plugin doesn't have health check, use basic status
+        return PluginHealthResponse(
+            plugin=plugin_name,
+            status="healthy",
+            adapter_loaded=True,
+            details={"type": "plugin", "active": True},
+        )
+
+        # Endpoints are loaded at startup only
+
+
+@router.get("/status", response_model=PluginStatusResponse)
+async def plugins_status(
+    request: Request, auth: ConditionalAuthDep = None
+) -> PluginStatusResponse:
+    """Get plugin system status, including manifests and init order.
+
+    Returns:
+        Initialization order, registered services, and per-plugin manifest summary
+    """
+    if not hasattr(request.app.state, "plugin_registry"):
+        raise HTTPException(status_code=503, detail="Plugin registry not initialized")
+
+    from ccproxy.core.plugins import PluginRegistry
+
+    registry: PluginRegistry = request.app.state.plugin_registry
+
+    # Get manifests and runtime status
+    entries: list[PluginStatusEntry] = []
+    for name in registry.list_plugins():
+        factory = registry.get_factory(name)
+        if not factory:
+            continue
+        manifest = factory.get_manifest()
+        runtime = registry.get_runtime(name)
+
+        # Determine plugin type via factory helper
+        from ccproxy.core.plugins import factory_type_name
+
+        plugin_type = factory_type_name(factory)
+
+        entries.append(
+            PluginStatusEntry(
+                name=name,
+                version=manifest.version,
+                type=plugin_type,
+                provides=list(manifest.provides),
+                requires=list(manifest.requires),
+                optional_requires=list(manifest.optional_requires),
+                initialized=runtime is not None
+                and getattr(runtime, "initialized", False),
+            )
+        )
+
+    # Extract init order and services map
+    init_order = list(getattr(registry, "initialization_order", []) or [])
+    services_map = dict(getattr(registry, "_service_providers", {}) or {})
+
+    return PluginStatusResponse(
+        initialization_order=init_order,
+        services=services_map,
+        plugins=entries,
+    )
+
+
+@router.delete("/{plugin_name}")
+async def unregister_plugin() -> dict[str, str]:
+    """Plugin unregistration is not supported in v2; endpoint removed."""
+    raise HTTPException(
+        status_code=status.HTTP_501_NOT_IMPLEMENTED,
+        detail="Plugin unregistration is not supported; restart with desired config.",
+    )

ccproxy/auth/__init__.py

@@ -1,15 +1,12 @@
 """Authentication module for centralized auth handling."""
 
 from ccproxy.auth.bearer import BearerTokenAuthManager
-from ccproxy.auth.credentials_adapter import CredentialsAuthManager
 from ccproxy.auth.dependencies import (
     AccessTokenDep,
     AuthManagerDep,
     RequiredAuthDep,
     get_access_token,
     get_auth_manager,
-    get_bearer_auth_manager,
-    get_credentials_auth_manager,
     require_auth,
 )
 from ccproxy.auth.exceptions import (
@@ -22,32 +19,22 @@ from ccproxy.auth.exceptions import (
     CredentialsStorageError,
     InsufficientPermissionsError,
     InvalidTokenError,
-    OAuthCallbackError,
     OAuthError,
-    OAuthLoginError,
     OAuthTokenRefreshError,
 )
-from ccproxy.auth.manager import AuthManager, BaseAuthManager
+from ccproxy.auth.manager import AuthManager
 from ccproxy.auth.storage import (
-    JsonFileTokenStorage,
-    KeyringTokenStorage,
     TokenStorage,
 )
-from ccproxy.services.credentials.manager import CredentialsManager
 
 
 __all__ = [
-    # Manager interfaces
+    # Manager interface
     "AuthManager",
-    "BaseAuthManager",
     # Implementations
     "BearerTokenAuthManager",
-    "CredentialsAuthManager",
-    "CredentialsManager",
     # Storage interfaces and implementations
     "TokenStorage",
-    "JsonFileTokenStorage",
-    "KeyringTokenStorage",
     # Exceptions
     "AuthenticationError",
     "AuthenticationRequiredError",
@@ -58,14 +45,10 @@ __all__ = [
     "CredentialsStorageError",
     "InvalidTokenError",
     "InsufficientPermissionsError",
-    "OAuthCallbackError",
     "OAuthError",
-    "OAuthLoginError",
     "OAuthTokenRefreshError",
     # Dependencies
     "get_auth_manager",
-    "get_bearer_auth_manager",
-    "get_credentials_auth_manager",
     "require_auth",
     "get_access_token",
     # Type aliases

ccproxy/auth/bearer.py

@@ -3,11 +3,11 @@
 from typing import Any
 
 from ccproxy.auth.exceptions import AuthenticationError
-from ccproxy.auth.manager import BaseAuthManager
-from ccproxy.auth.models import ClaudeCredentials, UserProfile
+from ccproxy.auth.models.credentials import BaseCredentials
+from ccproxy.auth.oauth.protocol import StandardProfileFields
 
 
-class BearerTokenAuthManager(BaseAuthManager):
+class BearerTokenAuthManager:
     """Authentication manager for static bearer tokens."""
 
     def __init__(self, token: str) -> None:
@@ -33,12 +33,8 @@ class BearerTokenAuthManager(BaseAuthManager):
             raise AuthenticationError("No bearer token available")
         return self.token
 
-    async def get_credentials(self) -> ClaudeCredentials:
-        """Get credentials (not supported for bearer tokens).
-
-        Raises:
-            AuthenticationError: Bearer tokens don't support full credentials
-        """
+    async def get_credentials(self) -> BaseCredentials:
+        """Bearer tokens do not expose structured credentials."""
         raise AuthenticationError(
             "Bearer token authentication doesn't support full credentials"
         )
@@ -51,12 +47,8 @@ class BearerTokenAuthManager(BaseAuthManager):
         """
         return bool(self.token)
 
-    async def get_user_profile(self) -> UserProfile | None:
-        """Get user profile (not supported for bearer tokens).
-
-        Returns:
-            None - bearer tokens don't support user profiles
-        """
+    async def get_user_profile(self) -> StandardProfileFields | None:
+        """Return ``None`` because bearer tokens have no profile context."""
         return None
 
     async def __aenter__(self) -> "BearerTokenAuthManager":
@@ -66,3 +58,21 @@ class BearerTokenAuthManager(BaseAuthManager):
     async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
         """Async context manager exit."""
         pass
+
+    # ==================== Provider-Generic Methods ====================
+
+    async def validate_credentials(self) -> bool:
+        """Validate that credentials are available and valid.
+
+        Returns:
+            True if credentials are valid, False otherwise
+        """
+        return bool(self.token)
+
+    def get_provider_name(self) -> str:
+        """Get the provider name for logging.
+
+        Returns:
+            Provider name string
+        """
+        return "bearer-token"