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

ccproxy/plugins/command_replay/hook.py

@@ -0,0 +1,294 @@
+"""Hook implementation for command replay generation."""
+
+from ccproxy.core.logging import get_plugin_logger
+from ccproxy.core.plugins.hooks import Hook
+from ccproxy.core.plugins.hooks.base import HookContext
+from ccproxy.core.plugins.hooks.events import HookEvent
+from ccproxy.core.request_context import RequestContext
+from ccproxy.utils.command_line import (
+    format_command_output,
+    generate_curl_command,
+    generate_xh_command,
+)
+
+from .config import CommandReplayConfig
+from .formatter import CommandFileFormatter
+
+
+logger = get_plugin_logger(__name__)
+
+
+class CommandReplayHook(Hook):
+    """Hook for generating curl and xh command replays of provider requests.
+
+    Listens for PROVIDER_REQUEST_PREPARED events and generates command line
+    equivalents that can be used to replay the exact same HTTP requests.
+    """
+
+    name = "command_replay"
+    events = [
+        HookEvent.PROVIDER_REQUEST_PREPARED,
+        # Also listen to HTTP_REQUEST for broader coverage
+        HookEvent.HTTP_REQUEST,
+    ]
+    priority = 200  # Run after core tracing but before heavy processing
+
+    def __init__(
+        self,
+        config: CommandReplayConfig | None = None,
+        file_formatter: CommandFileFormatter | None = None,
+    ) -> None:
+        """Initialize the command replay hook.
+
+        Args:
+            config: Command replay configuration
+            file_formatter: File formatter for writing commands to files
+        """
+        self.config = config or CommandReplayConfig()
+        self.file_formatter = file_formatter
+
+        logger.debug(
+            "command_replay_hook_initialized",
+            enabled=self.config.enabled,
+            generate_curl=self.config.generate_curl,
+            generate_xh=self.config.generate_xh,
+            include_patterns=self.config.include_url_patterns,
+            only_provider_requests=self.config.only_provider_requests,
+            include_client_requests=self.config.include_client_requests,
+            write_to_files=self.config.write_to_files,
+            log_dir=self.config.log_dir,
+        )
+
+    async def __call__(self, context: HookContext) -> None:
+        """Handle hook events for command replay generation.
+
+        Args:
+            context: Hook context with event data
+        """
+        if not self.config.enabled:
+            return
+
+        # Debug logging
+        logger.debug(
+            "command_replay_hook_called",
+            hook_event=context.event.value if context.event else "unknown",
+            data_keys=list(context.data.keys()) if context.data else [],
+        )
+
+        try:
+            if context.event == HookEvent.PROVIDER_REQUEST_PREPARED:
+                await self._handle_provider_request(context)
+            elif context.event == HookEvent.HTTP_REQUEST:
+                await self._handle_http_request(context)
+        except Exception as e:
+            logger.error(
+                "command_replay_hook_error",
+                hook_event=context.event.value if context.event else "unknown",
+                error=str(e),
+                exc_info=e,
+            )
+
+    async def _handle_provider_request(self, context: HookContext) -> None:
+        """Handle PROVIDER_REQUEST_PREPARED event."""
+        await self._generate_commands(context, is_provider_request=True)
+
+    async def _handle_http_request(self, context: HookContext) -> None:
+        """Handle HTTP_REQUEST event - for both provider and client requests."""
+        url = context.data.get("url", "")
+        is_provider = self._is_provider_request(url)
+
+        # Apply filtering based on configuration
+        if self.config.only_provider_requests and not is_provider:
+            return
+
+        if not self.config.include_client_requests and not is_provider:
+            return
+
+        await self._generate_commands(context, is_provider_request=is_provider)
+
+    async def _generate_commands(
+        self, context: HookContext, is_provider_request: bool = False
+    ) -> None:
+        """Generate curl and xh commands from request context.
+
+        Args:
+            context: Hook context with request data
+            is_provider_request: Whether this came from PROVIDER_REQUEST_PREPARED
+        """
+        # Extract request data
+        method = context.data.get("method", "GET")
+        url = context.data.get("url", "")
+        headers = context.data.get("headers", {})
+        body = context.data.get("body")
+        is_json = context.data.get("is_json", False)
+
+        # Get request ID for correlation
+        request_id = (
+            context.data.get("request_id")
+            or context.metadata.get("request_id")
+            or "unknown"
+        )
+
+        # Get provider name if available
+        provider = context.provider or self._extract_provider_from_url(url)
+
+        # Check if we should generate commands for this URL
+        if not self.config.should_generate_for_url(url, is_provider_request):
+            logger.debug(
+                "command_replay_skipped_url_filter",
+                request_id=request_id,
+                url=url,
+                provider=provider,
+                is_provider_request=is_provider_request,
+            )
+            return
+
+        # Validate we have minimum required data
+        if not url or not method:
+            logger.warning(
+                "command_replay_insufficient_data",
+                request_id=request_id,
+                has_url=bool(url),
+                has_method=bool(method),
+            )
+            return
+
+        commands = []
+
+        # Generate curl command
+        if self.config.generate_curl:
+            try:
+                curl_cmd = generate_curl_command(
+                    method=method,
+                    url=url,
+                    headers=headers,
+                    body=body,
+                    is_json=is_json,
+                    pretty=self.config.pretty_format,
+                )
+                commands.append(("curl", curl_cmd))
+            except Exception as e:
+                logger.error(
+                    "command_replay_curl_generation_error",
+                    request_id=request_id,
+                    error=str(e),
+                )
+
+        # Generate xh command
+        if self.config.generate_xh:
+            try:
+                xh_cmd = generate_xh_command(
+                    method=method,
+                    url=url,
+                    headers=headers,
+                    body=body,
+                    is_json=is_json,
+                    pretty=self.config.pretty_format,
+                )
+                commands.append(("xh", xh_cmd))
+            except Exception as e:
+                logger.error(
+                    "command_replay_xh_generation_error",
+                    request_id=request_id,
+                    error=str(e),
+                )
+
+        # Process generated commands
+        if commands:
+            curl_cmd = next((cmd for tool, cmd in commands if tool == "curl"), "")
+            xh_cmd = next((cmd for tool, cmd in commands if tool == "xh"), "")
+
+            # Write to files if enabled
+            written_files = []
+            if self.config.write_to_files and self.file_formatter:
+                try:
+                    # Get timestamp prefix from current request context if available
+                    timestamp_prefix = None
+                    try:
+                        current_context = RequestContext.get_current()
+                        if current_context:
+                            timestamp_prefix = (
+                                current_context.get_log_timestamp_prefix()
+                            )
+                    except Exception:
+                        pass
+
+                    written_files = await self.file_formatter.write_commands(
+                        request_id=request_id,
+                        curl_command=curl_cmd,
+                        xh_command=xh_cmd,
+                        provider=provider,
+                        timestamp_prefix=timestamp_prefix,
+                        method=method,
+                        url=url,
+                        headers=headers,
+                        body=body,
+                        is_json=is_json,
+                    )
+
+                    if written_files:
+                        logger.debug(
+                            "command_replay_files_written",
+                            request_id=request_id,
+                            files=written_files,
+                            provider=provider,
+                        )
+                except Exception as e:
+                    logger.error(
+                        "command_replay_file_write_failed",
+                        request_id=request_id,
+                        error=str(e),
+                        exc_info=e,
+                    )
+
+            # Log to console if enabled
+            if self.config.log_to_console:
+                output = format_command_output(
+                    request_id=request_id,
+                    curl_command=curl_cmd,
+                    xh_command=xh_cmd,
+                    provider=provider,
+                )
+
+                # Add file info to console output if files were written
+                if written_files:
+                    output += f"\n📁 Files written: {', '.join(written_files)}\n"
+
+                logger.debug("command_replay_generated", output=output)
+
+    def _is_provider_request(self, url: str) -> bool:
+        """Determine if this is a request to a provider API.
+
+        Args:
+            url: The request URL
+
+        Returns:
+            True if this is a provider request
+        """
+        provider_domains = [
+            "api.anthropic.com",
+            "claude.ai",
+            "api.openai.com",
+            "chatgpt.com",
+        ]
+
+        url_lower = url.lower()
+        return any(domain in url_lower for domain in provider_domains)
+
+    def _extract_provider_from_url(self, url: str) -> str | None:
+        """Extract provider name from URL.
+
+        Args:
+            url: The request URL
+
+        Returns:
+            Provider name or None if not recognized
+        """
+        url_lower = url.lower()
+
+        if "anthropic.com" in url_lower or "claude.ai" in url_lower:
+            return "anthropic"
+        elif "openai.com" in url_lower or "chatgpt.com" in url_lower:
+            return "openai"
+
+        return None

ccproxy/plugins/command_replay/plugin.py

@@ -0,0 +1,161 @@
+"""Command Replay plugin implementation."""
+
+from typing import Any
+
+from ccproxy.core.logging import get_plugin_logger
+from ccproxy.core.plugins import (
+    PluginManifest,
+    SystemPluginFactory,
+    SystemPluginRuntime,
+)
+from ccproxy.core.plugins.hooks import HookRegistry
+
+from .config import CommandReplayConfig
+from .formatter import CommandFileFormatter
+from .hook import CommandReplayHook
+
+
+logger = get_plugin_logger()
+
+
+class CommandReplayRuntime(SystemPluginRuntime):
+    """Runtime for the command replay plugin.
+
+    Generates curl and xh commands for provider requests to enable
+    easy replay and debugging of API calls.
+    """
+
+    def __init__(self, manifest: PluginManifest):
+        """Initialize runtime."""
+        super().__init__(manifest)
+        self.config: CommandReplayConfig | None = None
+        self.hook: CommandReplayHook | None = None
+        self.file_formatter: CommandFileFormatter | None = None
+
+    async def _on_initialize(self) -> None:
+        """Initialize the command replay plugin."""
+        if not self.context:
+            raise RuntimeError("Context not set")
+
+        # Get configuration
+        config = self.context.get("config")
+        if not isinstance(config, CommandReplayConfig):
+            logger.debug("plugin_no_config")
+            config = CommandReplayConfig()
+            logger.debug("plugin_using_default_config")
+        self.config = config
+
+        # Debug log the configuration being used
+        logger.debug(
+            "plugin_configuration_loaded",
+            enabled=config.enabled,
+            generate_curl=config.generate_curl,
+            generate_xh=config.generate_xh,
+            include_patterns=config.include_url_patterns,
+            exclude_patterns=config.exclude_url_patterns,
+            log_to_console=config.log_to_console,
+            log_level=config.log_level,
+            only_provider_requests=config.only_provider_requests,
+        )
+
+        if self.config.enabled:
+            # Initialize file formatter if file writing is enabled
+            if self.config.write_to_files:
+                self.file_formatter = CommandFileFormatter(
+                    log_dir=self.config.log_dir,
+                    enabled=True,
+                    separate_files_per_command=self.config.separate_files_per_command,
+                )
+                logger.debug(
+                    "command_replay_file_formatter_initialized",
+                    log_dir=self.config.log_dir,
+                    separate_files=self.config.separate_files_per_command,
+                )
+
+            # Register hook for provider request events
+            self.hook = CommandReplayHook(
+                config=self.config,
+                file_formatter=self.file_formatter,
+            )
+
+            # Try to get hook registry from context
+            hook_registry = self.context.get("hook_registry")
+
+            # If not found, try app state
+            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 and isinstance(hook_registry, HookRegistry):
+                hook_registry.register(self.hook)
+                logger.debug(
+                    "command_replay_hook_registered",
+                    events=self.hook.events,
+                    priority=self.hook.priority,
+                    generate_curl=self.config.generate_curl,
+                    generate_xh=self.config.generate_xh,
+                    write_to_files=self.config.write_to_files,
+                    log_dir=self.config.log_dir if self.config.write_to_files else None,
+                )
+            else:
+                logger.warning(
+                    "hook_registry_not_available",
+                    fallback="disabled",
+                )
+        else:
+            logger.debug("command_replay_plugin_disabled")
+
+    async def _on_shutdown(self) -> None:
+        """Clean up plugin resources."""
+        if self.hook:
+            logger.info("command_replay_plugin_shutdown")
+            self.hook = None
+
+        if self.file_formatter:
+            self.file_formatter.cleanup()
+            self.file_formatter = None
+
+    def get_health_info(self) -> dict[str, Any]:
+        """Get plugin health information."""
+        return {
+            "enabled": self.config.enabled if self.config else False,
+            "hook_registered": self.hook is not None,
+            "generate_curl": self.config.generate_curl if self.config else False,
+            "generate_xh": self.config.generate_xh if self.config else False,
+            "write_to_files": self.config.write_to_files if self.config else False,
+            "file_formatter_enabled": self.file_formatter is not None,
+            "log_dir": self.config.log_dir if self.config else None,
+        }
+
+
+class CommandReplayFactory(SystemPluginFactory):
+    """Factory for creating command replay plugin instances."""
+
+    def __init__(self) -> None:
+        """Initialize factory with manifest."""
+        # Create manifest with static declarations
+        manifest = PluginManifest(
+            name="command_replay",
+            version="0.1.0",
+            description="Generates curl and xh commands for provider requests",
+            is_provider=False,
+            config_class=CommandReplayConfig,
+        )
+
+        # Initialize with manifest
+        super().__init__(manifest)
+
+    def create_runtime(self) -> CommandReplayRuntime:
+        """Create runtime instance."""
+        return CommandReplayRuntime(self.manifest)
+
+    def create_context(self, core_services: Any) -> Any:
+        """Create context for the plugin."""
+        # Get base context from parent
+        context = super().create_context(core_services)
+        return context
+
+
+# Export the factory for plugin discovery
+factory = CommandReplayFactory()

ccproxy/plugins/copilot/README.md

@@ -0,0 +1,39 @@
+# Copilot Plugin
+
+Adds GitHub Copilot as a provider with OAuth, detection, and streaming support.
+
+## Highlights
+- Wraps the Copilot HTTP adapter while emitting OpenAI-compatible streams
+- Manages OAuth exchange and token refresh through `CopilotOAuthProvider`
+- Exposes GitHub-flavored routes under `/copilot` alongside v1 proxy APIs
+
+## Configuration
+- `CopilotConfig` controls base URLs, scopes, cache paths, and CLI detection
+- Depends on `CopilotTokenManager` for credential storage and refresh logic
+- Generate defaults with `python3 scripts/generate_config_from_model.py \
+  --format toml --plugin copilot --config-class CopilotConfig`
+
+```toml
+[plugins.copilot]
+# enabled = true
+# base_url = "https://api.githubcopilot.com"
+# auth_type = "oauth"
+# supports_streaming = true
+# default_max_tokens = 4096
+# account_type = "individual"
+# request_timeout = 30
+# max_retries = 3
+# retry_delay = 1.0
+
+[plugins.copilot.oauth]
+# client_id = "Iv1.b507a08c87ecfe98"
+# authorize_url = "https://github.com/login/device/code"
+# token_url = "https://github.com/login/oauth/access_token"
+# callback_port = 8080
+# scopes = ["read:user"]
+```
+
+## Related Components
+- `adapter.py`: request translation and HTTP execution layer
+- `oauth/provider.py`: OAuth flow implementation for GitHub accounts
+- `routes.py`: FastAPI routers for GitHub and proxy endpoints

ccproxy/plugins/copilot/__init__.py

@@ -0,0 +1,11 @@
+"""GitHub Copilot provider plugin for CCProxy.
+
+This plugin provides OAuth authentication with GitHub and API proxying
+capabilities for GitHub Copilot services, following the established patterns
+from existing OAuth Claude and Codex plugins.
+"""
+
+from .plugin import CopilotPluginFactory, CopilotPluginRuntime, factory
+
+
+__all__ = ["CopilotPluginFactory", "CopilotPluginRuntime", "factory"]