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

ccproxy/services/codex_detection_service.py

@@ -1,252 +0,0 @@
-"""Service for automatically detecting Codex CLI headers at startup."""
-
-from __future__ import annotations
-
-import asyncio
-import json
-import os
-import socket
-import subprocess
-from pathlib import Path
-from typing import Any
-
-import structlog
-from fastapi import FastAPI, Request, Response
-
-from ccproxy.config.discovery import get_ccproxy_cache_dir
-from ccproxy.config.settings import Settings
-from ccproxy.models.detection import (
-    CodexCacheData,
-    CodexHeaders,
-    CodexInstructionsData,
-)
-
-
-logger = structlog.get_logger(__name__)
-
-
-class CodexDetectionService:
-    """Service for automatically detecting Codex CLI headers at startup."""
-
-    def __init__(self, settings: Settings) -> None:
-        """Initialize Codex detection service."""
-        self.settings = settings
-        self.cache_dir = get_ccproxy_cache_dir()
-        self.cache_dir.mkdir(parents=True, exist_ok=True)
-        self._cached_data: CodexCacheData | None = None
-
-    async def initialize_detection(self) -> CodexCacheData:
-        """Initialize Codex detection at startup."""
-        try:
-            # Get current Codex version
-            current_version = await self._get_codex_version()
-
-            # Try to load from cache first
-            detected_data = self._load_from_cache(current_version)
-            cached = detected_data is not None
-            if cached:
-                logger.debug("detection_codex_headers_debug", version=current_version)
-            else:
-                # No cache or version changed - detect fresh
-                detected_data = await self._detect_codex_headers(current_version)
-                # Cache the results
-                self._save_to_cache(detected_data)
-
-            self._cached_data = detected_data
-
-            logger.info(
-                "detection_codex_headers_completed",
-                version=current_version,
-                cached=cached,
-            )
-
-            # TODO: add proper testing without codex cli installed
-            if detected_data is None:
-                raise ValueError("Codex detection failed")
-            return detected_data
-
-        except Exception as e:
-            logger.warning("detection_codex_headers_failed", fallback=True, error=e)
-            # Return fallback data
-            fallback_data = self._get_fallback_data()
-            self._cached_data = fallback_data
-            return fallback_data
-
-    def get_cached_data(self) -> CodexCacheData | None:
-        """Get currently cached detection data."""
-        return self._cached_data
-
-    async def _get_codex_version(self) -> str:
-        """Get Codex CLI version."""
-        try:
-            result = subprocess.run(
-                ["codex", "--version"],
-                capture_output=True,
-                text=True,
-                timeout=10,
-            )
-            if result.returncode == 0:
-                # Extract version from output like "codex 0.21.0"
-                version_line = result.stdout.strip()
-                if " " in version_line:
-                    # Handle "codex 0.21.0" format - extract just the version number
-                    return version_line.split()[-1]
-                return version_line
-            else:
-                raise RuntimeError(f"Codex version command failed: {result.stderr}")
-
-        except (subprocess.TimeoutExpired, FileNotFoundError, RuntimeError) as e:
-            logger.warning("codex_version_detection_failed", error=str(e))
-            return "unknown"
-
-    async def _detect_codex_headers(self, version: str) -> CodexCacheData:
-        """Execute Codex CLI with proxy to capture headers and instructions."""
-        # Data captured from the request
-        captured_data: dict[str, Any] = {}
-
-        async def capture_handler(request: Request) -> Response:
-            """Capture the Codex CLI request."""
-            captured_data["headers"] = dict(request.headers)
-            captured_data["body"] = await request.body()
-            # Return a mock response to satisfy Codex CLI
-            return Response(
-                content='{"choices": [{"message": {"content": "Test response"}}]}',
-                media_type="application/json",
-                status_code=200,
-            )
-
-        # Create temporary FastAPI app
-        temp_app = FastAPI()
-        temp_app.post("/backend-api/codex/responses")(capture_handler)
-
-        # Find available port
-        sock = socket.socket()
-        sock.bind(("", 0))
-        port = sock.getsockname()[1]
-        sock.close()
-
-        # Start server in background
-        from uvicorn import Config, Server
-
-        config = Config(temp_app, host="127.0.0.1", port=port, log_level="error")
-        server = Server(config)
-
-        logger.debug("start")
-        server_task = asyncio.create_task(server.serve())
-
-        try:
-            # Wait for server to start
-            await asyncio.sleep(0.5)
-
-            # Execute Codex CLI with proxy
-            env = {
-                **dict(os.environ),
-                "OPENAI_BASE_URL": f"http://127.0.0.1:{port}/backend-api/codex",
-            }
-
-            process = await asyncio.create_subprocess_exec(
-                "codex",
-                "exec",
-                "test",
-                env=env,
-                stdout=asyncio.subprocess.PIPE,
-                stderr=asyncio.subprocess.PIPE,
-            )
-            # stderr = ""
-            # if process.stderr:
-            #     stderr = await process.stderr.read(128)
-            # stdout = ""
-            # if process.stdout:
-            #     stdout = await process.stdout.read(128)
-            # logger.warning("rcecdy", stderr=stderr, stdout=stdout)
-
-            # Wait for process with timeout
-            try:
-                await asyncio.wait_for(process.wait(), timeout=300)
-            except TimeoutError:
-                process.kill()
-                await process.wait()
-
-            # Stop server
-            server.should_exit = True
-            await server_task
-
-            if not captured_data:
-                raise RuntimeError("Failed to capture Codex CLI request")
-
-            # Extract headers and instructions
-            headers = self._extract_headers(captured_data["headers"])
-            instructions = self._extract_instructions(captured_data["body"])
-
-            return CodexCacheData(
-                codex_version=version, headers=headers, instructions=instructions
-            )
-
-        except Exception as e:
-            # Ensure server is stopped
-            server.should_exit = True
-            if not server_task.done():
-                await server_task
-            raise
-
-    def _load_from_cache(self, version: str) -> CodexCacheData | None:
-        """Load cached data for specific Codex version."""
-        cache_file = self.cache_dir / f"codex_headers_{version}.json"
-
-        if not cache_file.exists():
-            return None
-
-        try:
-            with cache_file.open("r") as f:
-                data = json.load(f)
-                return CodexCacheData.model_validate(data)
-        except Exception:
-            return None
-
-    def _save_to_cache(self, data: CodexCacheData) -> None:
-        """Save detection data to cache."""
-        cache_file = self.cache_dir / f"codex_headers_{data.codex_version}.json"
-
-        try:
-            with cache_file.open("w") as f:
-                json.dump(data.model_dump(), f, indent=2, default=str)
-            logger.debug(
-                "cache_saved", file=str(cache_file), version=data.codex_version
-            )
-        except Exception as e:
-            logger.warning("cache_save_failed", file=str(cache_file), error=str(e))
-
-    def _extract_headers(self, headers: dict[str, str]) -> CodexHeaders:
-        """Extract Codex CLI headers from captured request."""
-        try:
-            return CodexHeaders.model_validate(headers)
-        except Exception as e:
-            logger.error("header_extraction_failed", error=str(e))
-            raise ValueError(f"Failed to extract required headers: {e}") from e
-
-    def _extract_instructions(self, body: bytes) -> CodexInstructionsData:
-        """Extract instructions from captured request body."""
-        try:
-            data = json.loads(body.decode("utf-8"))
-            instructions_content = data.get("instructions")
-
-            if instructions_content is None:
-                raise ValueError("No instructions field found in request body")
-
-            return CodexInstructionsData(instructions_field=instructions_content)
-
-        except Exception as e:
-            logger.error("instructions_extraction_failed", error=str(e))
-            raise ValueError(f"Failed to extract instructions: {e}") from e
-
-    def _get_fallback_data(self) -> CodexCacheData:
-        """Get fallback data when detection fails."""
-        logger.warning("using_fallback_codex_data")
-
-        # Load fallback data from package data file
-        package_data_file = (
-            Path(__file__).parent.parent / "data" / "codex_headers_fallback.json"
-        )
-        with package_data_file.open("r") as f:
-            fallback_data_dict = json.load(f)
-            return CodexCacheData.model_validate(fallback_data_dict)

ccproxy/services/credentials/__init__.py

@@ -1,55 +0,0 @@
-"""Credentials management package."""
-
-from ccproxy.auth.exceptions import (
-    CredentialsError,
-    CredentialsExpiredError,
-    CredentialsInvalidError,
-    CredentialsNotFoundError,
-    CredentialsStorageError,
-    OAuthCallbackError,
-    OAuthError,
-    OAuthLoginError,
-    OAuthTokenRefreshError,
-)
-from ccproxy.auth.models import (
-    AccountInfo,
-    ClaudeCredentials,
-    OAuthToken,
-    OrganizationInfo,
-    UserProfile,
-)
-from ccproxy.auth.storage import JsonFileTokenStorage as JsonFileStorage
-from ccproxy.auth.storage import TokenStorage as CredentialsStorageBackend
-from ccproxy.services.credentials.config import CredentialsConfig, OAuthConfig
-from ccproxy.services.credentials.manager import CredentialsManager
-from ccproxy.services.credentials.oauth_client import OAuthClient
-
-
-__all__ = [
-    # Manager
-    "CredentialsManager",
-    # Config
-    "CredentialsConfig",
-    "OAuthConfig",
-    # Models
-    "ClaudeCredentials",
-    "OAuthToken",
-    "OrganizationInfo",
-    "AccountInfo",
-    "UserProfile",
-    # Storage
-    "CredentialsStorageBackend",
-    "JsonFileStorage",
-    # OAuth
-    "OAuthClient",
-    # Exceptions
-    "CredentialsError",
-    "CredentialsNotFoundError",
-    "CredentialsInvalidError",
-    "CredentialsExpiredError",
-    "CredentialsStorageError",
-    "OAuthError",
-    "OAuthLoginError",
-    "OAuthTokenRefreshError",
-    "OAuthCallbackError",
-]

ccproxy/services/credentials/config.py

@@ -1,105 +0,0 @@
-"""Configuration for credentials and OAuth."""
-
-import os
-
-from pydantic import BaseModel, Field
-
-
-def _get_default_storage_paths() -> list[str]:
-    """Get default storage paths, with test override support."""
-    # Allow tests to override credential paths
-    if os.getenv("CCPROXY_TEST_MODE") == "true":
-        # Use a test-specific location that won't pollute real credentials
-        return [
-            "/tmp/ccproxy-test/.config/claude/.credentials.json",
-            "/tmp/ccproxy-test/.claude/.credentials.json",
-        ]
-
-    return [
-        "~/.config/claude/.credentials.json",  # Alternative legacy location
-        "~/.claude/.credentials.json",  # Legacy location
-        "~/.config/ccproxy/credentials.json",  # location in app config
-    ]
-
-
-class OAuthConfig(BaseModel):
-    """OAuth configuration settings."""
-
-    base_url: str = Field(
-        default="https://console.anthropic.com",
-        description="Base URL for OAuth API endpoints",
-    )
-    beta_version: str = Field(
-        default="oauth-2025-04-20",
-        description="OAuth beta version header",
-    )
-    token_url: str = Field(
-        default="https://console.anthropic.com/v1/oauth/token",
-        description="OAuth token endpoint URL",
-    )
-    authorize_url: str = Field(
-        default="https://claude.ai/oauth/authorize",
-        description="OAuth authorization endpoint URL",
-    )
-    profile_url: str = Field(
-        default="https://api.anthropic.com/api/oauth/profile",
-        description="OAuth profile endpoint URL",
-    )
-    client_id: str = Field(
-        default="9d1c250a-e61b-44d9-88ed-5944d1962f5e",
-        description="OAuth client ID",
-    )
-    redirect_uri: str = Field(
-        default="http://localhost:54545/callback",
-        description="OAuth redirect URI",
-    )
-    scopes: list[str] = Field(
-        default_factory=lambda: [
-            "org:create_api_key",
-            "user:profile",
-            "user:inference",
-        ],
-        description="OAuth scopes to request",
-    )
-    request_timeout: int = Field(
-        default=30,
-        description="Timeout in seconds for OAuth requests",
-    )
-    user_agent: str = Field(
-        default="Claude-Code/1.0.43",
-        description="User agent string for OAuth requests",
-    )
-    callback_timeout: int = Field(
-        default=300,
-        description="Timeout in seconds for OAuth callback",
-        ge=60,
-        le=600,
-    )
-    callback_port: int = Field(
-        default=54545,
-        description="Port for OAuth callback server",
-        ge=1024,
-        le=65535,
-    )
-
-
-class CredentialsConfig(BaseModel):
-    """Configuration for credentials management."""
-
-    storage_paths: list[str] = Field(
-        default_factory=lambda: _get_default_storage_paths(),
-        description="Paths to search for credentials files",
-    )
-    oauth: OAuthConfig = Field(
-        default_factory=OAuthConfig,
-        description="OAuth configuration",
-    )
-    auto_refresh: bool = Field(
-        default=True,
-        description="Automatically refresh expired tokens",
-    )
-    refresh_buffer_seconds: int = Field(
-        default=300,
-        description="Refresh token this many seconds before expiry",
-        ge=0,
-    )