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

ccproxy/plugins/permissions/__init__.py

@@ -0,0 +1,22 @@
+"""Permissions plugin for CCProxy.
+
+Provides permission management and authorization services.
+"""
+
+from .models import (
+    EventType,
+    PermissionEvent,
+    PermissionRequest,
+    PermissionStatus,
+)
+from .service import PermissionService, get_permission_service
+
+
+__all__ = [
+    "EventType",
+    "PermissionEvent",
+    "PermissionRequest",
+    "PermissionService",
+    "PermissionStatus",
+    "get_permission_service",
+]

ccproxy/plugins/permissions/config.py

@@ -0,0 +1,28 @@
+"""Configuration for permissions plugin."""
+
+from pydantic import BaseModel, Field
+
+
+class PermissionsConfig(BaseModel):
+    """Configuration for the permissions plugin."""
+
+    enabled: bool = Field(
+        default=True,
+        description="Enable the permissions service",
+    )
+    timeout_seconds: int = Field(
+        default=30,
+        description="Default timeout for permission requests in seconds",
+    )
+    enable_terminal_ui: bool = Field(
+        default=True,
+        description="Enable terminal UI for permission requests",
+    )
+    enable_sse_stream: bool = Field(
+        default=True,
+        description="Enable SSE streaming endpoint for external handlers",
+    )
+    cleanup_after_minutes: int = Field(
+        default=5,
+        description="Minutes to keep resolved requests before cleanup",
+    )

ccproxy/{cli/commands/permission_handler.py → plugins/permissions/handlers/cli.py}

@@ -8,19 +8,20 @@ from collections.abc import AsyncIterator
 from typing import Any
 
 import httpx
-import structlog
 import typer
-from structlog import get_logger
+from pydantic import ValidationError
 
-from ccproxy.api.services.permission_service import PermissionRequest
-from ccproxy.api.ui.permission_handler_protocol import ConfirmationHandlerProtocol
-from ccproxy.api.ui.terminal_permission_handler import (
-    TerminalPermissionHandler as TextualPermissionHandler,
-)
-from ccproxy.config.settings import get_settings
+import ccproxy.core.logging
+from ccproxy.config.settings import Settings
+from ccproxy.core.async_task_manager import create_managed_task
+from ccproxy.core.logging import get_plugin_logger
+
+from ..models import PermissionRequest
+from .protocol import ConfirmationHandlerProtocol
+from .terminal import TerminalPermissionHandler as TextualPermissionHandler
 
 
-logger = get_logger(__name__)
+logger = get_plugin_logger()
 
 app = typer.Typer(
     name="confirmation-handler",
@@ -84,7 +85,7 @@ class SSEConfirmationHandler:
         if event_type == "ping":
             return
 
-        from ccproxy.models.permissions import EventType
+        from ..models import EventType
 
         handler_map = {
             EventType.PERMISSION_REQUEST.value: self._handle_permission_request,
@@ -95,7 +96,9 @@ class SSEConfirmationHandler:
         if handler:
             await handler(data)
         else:
-            logger.warning("unhandled_sse_event", event_type=event_type)
+            logger.warning(
+                "unhandled_sse_event", event_type=event_type, category="streaming"
+            )
 
     async def _handle_permission_request(self, data: dict[str, Any]) -> None:
         """Handle a confirmation request event.
@@ -136,15 +139,25 @@ class SSEConfirmationHandler:
             if "request_id" in request_data:
                 request_data["id"] = request_data.pop("request_id")
             request = PermissionRequest.model_validate(request_data)
+        except ValidationError as e:
+            logger.error(
+                "permission_request_validation_failed",
+                data=data,
+                error=str(e),
+                exc_info=e,
+            )
+            return
         except Exception as e:
             logger.error(
-                "permission_request_validation_failed", data=data, error=str(e)
+                "permission_request_parsing_error", data=data, error=str(e), exc_info=e
             )
             return
 
         if self.ui and request_id is not None:
-            task = asyncio.create_task(
-                self._handle_permission_with_cancellation(request)
+            task = await create_managed_task(
+                self._handle_permission_with_cancellation(request),
+                name=f"cli_permission_handler_{request_id}",
+                creator="CLIConfirmationHandler",
             )
             self._ongoing_requests[request_id] = task
 
@@ -239,7 +252,7 @@ class SSEConfirmationHandler:
                 "permission_handling_error",
                 request_id=request.id,
                 error=str(e),
-                exc_info=True,
+                exc_info=e,
             )
             # Only send response if not already resolved
             if request.id not in self._resolved_requests:
@@ -286,12 +299,19 @@ class SSEConfirmationHandler:
                     response=response.text,
                 )
 
+        except httpx.RequestError as e:
+            logger.error(
+                "permission_response_network_error",
+                request_id=request_id,
+                error=str(e),
+                exc_info=e,
+            )
         except Exception as e:
             logger.error(
                 "permission_response_error",
                 request_id=request_id,
                 error=str(e),
-                exc_info=True,
+                exc_info=e,
             )
 
     async def parse_sse_stream(
@@ -405,7 +425,9 @@ class SSEConfirmationHandler:
                 continue
 
             except Exception as e:
-                logger.error("sse_client_error", error=str(e), exc_info=True)
+                logger.error(
+                    "sse_client_error", error=str(e), exc_info=e, category="streaming"
+                )
                 raise typer.Exit(1) from e
 
     async def _connect_and_handle_stream(self, stream_url: str) -> None:
@@ -458,7 +480,7 @@ class SSEConfirmationHandler:
                         "sse_event_error",
                         event_type=event_type,
                         error=str(e),
-                        exc_info=True,
+                        exc_info=e,
                     )
 
 
@@ -511,19 +533,21 @@ def connect(
     # Configure root logger level
     logging.basicConfig(level=log_level)
 
-    # Configure structlog to respect the same log level
-    structlog.configure(
-        wrapper_class=structlog.make_filtering_bound_logger(log_level),
-    )
+    # Configure ccproxy.core.logging to respect the same log level
+    ccproxy.core.logging.configure_structlog(log_level)
 
-    settings = get_settings()
+    settings = Settings.from_config()
 
     # Use provided URL or default from settings
     if not api_url:
         api_url = f"http://{settings.server.host}:{settings.server.port}"
 
     # Determine auth token: CLI arg > config setting > None
-    token = auth_token or settings.security.auth_token
+    token = auth_token or (
+        settings.security.auth_token.get_secret_value()
+        if settings.security.auth_token
+        else None
+    )
 
     # Create handlers based on UI mode selection
     terminal_handler: ConfirmationHandlerProtocol = TextualPermissionHandler()
@@ -545,7 +569,7 @@ def connect(
     except KeyboardInterrupt:
         logger.info("permission_handler_stopped")
     except Exception as e:
-        logger.error("permission_handler_error", error=str(e), exc_info=True)
+        logger.error("permission_handler_error", error=str(e), exc_info=e)
         raise typer.Exit(1) from e
 
 

ccproxy/plugins/permissions/handlers/protocol.py

@@ -0,0 +1,33 @@
+"""Protocol definition for confirmation handlers."""
+
+from typing import Protocol
+
+from ..models import PermissionRequest
+
+
+class ConfirmationHandlerProtocol(Protocol):
+    """Protocol for confirmation request handlers.
+
+    This protocol defines the interface that all confirmation handlers
+    must implement to be compatible with the CLI confirmation system.
+    """
+
+    async def handle_permission(self, request: PermissionRequest) -> bool:
+        """Handle a permission request.
+
+        Args:
+            request: The permission request to handle
+
+        Returns:
+            bool: True if the user confirmed, False otherwise
+        """
+        ...
+
+    def cancel_confirmation(self, request_id: str, reason: str = "cancelled") -> None:
+        """Cancel an ongoing confirmation request.
+
+        Args:
+            request_id: The ID of the request to cancel
+            reason: The reason for cancellation
+        """
+        ...