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

ccproxy/services/claude_detection_service.py

@@ -1,269 +0,0 @@
-"""Service for automatically detecting Claude CLI headers at startup."""
-
-from __future__ import annotations
-
-import asyncio
-import json
-import os
-import socket
-import subprocess
-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 (
-    ClaudeCacheData,
-    ClaudeCodeHeaders,
-    SystemPromptData,
-)
-
-
-logger = structlog.get_logger(__name__)
-
-
-class ClaudeDetectionService:
-    """Service for automatically detecting Claude CLI headers at startup."""
-
-    def __init__(self, settings: Settings) -> None:
-        """Initialize Claude detection service."""
-        self.settings = settings
-        self.cache_dir = get_ccproxy_cache_dir()
-        self.cache_dir.mkdir(parents=True, exist_ok=True)
-        self._cached_data: ClaudeCacheData | None = None
-
-    async def initialize_detection(self) -> ClaudeCacheData:
-        """Initialize Claude detection at startup."""
-        try:
-            # Get current Claude version
-            current_version = await self._get_claude_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_claude_headers_debug", version=current_version)
-            else:
-                # No cache or version changed - detect fresh
-                detected_data = await self._detect_claude_headers(current_version)
-                # Cache the results
-                self._save_to_cache(detected_data)
-
-            self._cached_data = detected_data
-
-            logger.info(
-                "detection_claude_headers_completed",
-                version=current_version,
-                cached=cached,
-            )
-
-            # TODO: add proper testing without claude cli installed
-            if detected_data is None:
-                raise ValueError("Claude detection failed")
-            return detected_data
-
-        except Exception as e:
-            logger.warning("detection_claude_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) -> ClaudeCacheData | None:
-        """Get currently cached detection data."""
-        return self._cached_data
-
-    async def _get_claude_version(self) -> str:
-        """Get Claude CLI version."""
-        try:
-            result = subprocess.run(
-                ["claude", "--version"],
-                capture_output=True,
-                text=True,
-                timeout=10,
-            )
-            if result.returncode == 0:
-                # Extract version from output like "1.0.60 (Claude Code)"
-                version_line = result.stdout.strip()
-                if "/" in version_line:
-                    # Handle "claude-cli/1.0.60" format
-                    version_line = version_line.split("/")[-1]
-                if "(" in version_line:
-                    # Handle "1.0.60 (Claude Code)" format - extract just the version number
-                    return version_line.split("(")[0].strip()
-                return version_line
-            else:
-                raise RuntimeError(f"Claude version command failed: {result.stderr}")
-
-        except (subprocess.TimeoutExpired, FileNotFoundError, RuntimeError) as e:
-            logger.warning("claude_version_detection_failed", error=str(e))
-            return "unknown"
-
-    async def _detect_claude_headers(self, version: str) -> ClaudeCacheData:
-        """Execute Claude CLI with proxy to capture headers and system prompt."""
-        # Data captured from the request
-        captured_data: dict[str, Any] = {}
-
-        async def capture_handler(request: Request) -> Response:
-            """Capture the Claude CLI request."""
-            captured_data["headers"] = dict(request.headers)
-            captured_data["body"] = await request.body()
-            # Return a mock response to satisfy Claude CLI
-            return Response(
-                content='{"type": "message", "content": [{"type": "text", "text": "Test response"}]}',
-                media_type="application/json",
-                status_code=200,
-            )
-
-        # Create temporary FastAPI app
-        temp_app = FastAPI()
-        temp_app.post("/v1/messages")(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)
-
-        server_task = asyncio.create_task(server.serve())
-
-        try:
-            # Wait for server to start
-            await asyncio.sleep(0.5)
-
-            # Execute Claude CLI with proxy
-            env = {**dict(os.environ), "ANTHROPIC_BASE_URL": f"http://127.0.0.1:{port}"}
-
-            process = await asyncio.create_subprocess_exec(
-                "claude",
-                "test",
-                env=env,
-                stdout=asyncio.subprocess.PIPE,
-                stderr=asyncio.subprocess.PIPE,
-            )
-
-            # Wait for process with timeout
-            try:
-                await asyncio.wait_for(process.wait(), timeout=30)
-            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 Claude CLI request")
-
-            # Extract headers and system prompt
-            headers = self._extract_headers(captured_data["headers"])
-            system_prompt = self._extract_system_prompt(captured_data["body"])
-
-            return ClaudeCacheData(
-                claude_version=version, headers=headers, system_prompt=system_prompt
-            )
-
-        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) -> ClaudeCacheData | None:
-        """Load cached data for specific Claude version."""
-        cache_file = self.cache_dir / f"claude_headers_{version}.json"
-
-        if not cache_file.exists():
-            return None
-
-        try:
-            with cache_file.open("r") as f:
-                data = json.load(f)
-                return ClaudeCacheData.model_validate(data)
-        except Exception:
-            return None
-
-    def _save_to_cache(self, data: ClaudeCacheData) -> None:
-        """Save detection data to cache."""
-        cache_file = self.cache_dir / f"claude_headers_{data.claude_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.claude_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]) -> ClaudeCodeHeaders:
-        """Extract Claude CLI headers from captured request."""
-        try:
-            return ClaudeCodeHeaders.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_system_prompt(self, body: bytes) -> SystemPromptData:
-        """Extract system prompt from captured request body."""
-        try:
-            data = json.loads(body.decode("utf-8"))
-            system_content = data.get("system")
-
-            if system_content is None:
-                raise ValueError("No system field found in request body")
-
-            return SystemPromptData(system_field=system_content)
-
-        except Exception as e:
-            logger.error("system_prompt_extraction_failed", error=str(e))
-            raise ValueError(f"Failed to extract system prompt: {e}") from e
-
-    def _get_fallback_data(self) -> ClaudeCacheData:
-        """Get fallback data when detection fails."""
-        logger.warning("using_fallback_claude_data")
-
-        # Use existing hardcoded values as fallback
-        fallback_headers = ClaudeCodeHeaders(
-            **{
-                "anthropic-beta": "claude-code-20250219,oauth-2025-04-20,interleaved-thinking-2025-05-14,fine-grained-tool-streaming-2025-05-14",
-                "anthropic-version": "2023-06-01",
-                "anthropic-dangerous-direct-browser-access": "true",
-                "x-app": "cli",
-                "User-Agent": "claude-cli/1.0.60 (external, cli)",
-                "X-Stainless-Lang": "js",
-                "X-Stainless-Retry-Count": "0",
-                "X-Stainless-Timeout": "60",
-                "X-Stainless-Package-Version": "0.55.1",
-                "X-Stainless-OS": "Linux",
-                "X-Stainless-Arch": "x64",
-                "X-Stainless-Runtime": "node",
-                "X-Stainless-Runtime-Version": "v24.3.0",
-            }
-        )
-
-        fallback_prompt = SystemPromptData(
-            system_field=[
-                {
-                    "type": "text",
-                    "text": "You are Claude Code, Anthropic's official CLI for Claude.",
-                    "cache_control": {"type": "ephemeral"},
-                }
-            ]
-        )
-
-        return ClaudeCacheData(
-            claude_version="fallback",
-            headers=fallback_headers,
-            system_prompt=fallback_prompt,
-        )

ccproxy/services/codex_detection_service.py

@@ -1,263 +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 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")
-
-        # Use hardcoded values as fallback from req.json
-        fallback_headers = CodexHeaders(
-            session_id="",  # Will be generated per request
-            originator="codex_cli_rs",
-            **{"openai-beta": "responses=experimental"},
-            version="0.21.0",
-            **{"chatgpt-account-id": ""},  # Will be set from auth
-        )
-
-        # Use exact instructions from req.json
-        fallback_instructions = CodexInstructionsData(
-            instructions_field='You are a coding agent running in the Codex CLI, a terminal-based coding assistant. Codex CLI is an open source project led by OpenAI. You are expected to be precise, safe, and helpful.\n\nYour capabilities:\n- Receive user prompts and other context provided by the harness, such as files in the workspace.\n- Communicate with the user by streaming thinking & responses, and by making & updating plans.\n- Emit function calls to run terminal commands and apply patches. Depending on how this specific run is configured, you can request that these function calls be escalated to the user for approval before running. More on this in the "Sandbox and approvals" section.\n\nWithin this context, Codex refers to the open-source agentic coding interface (not the old Codex language model built by OpenAI).'
-        )
-
-        return CodexCacheData(
-            codex_version="fallback",
-            headers=fallback_headers,
-            instructions=fallback_instructions,
-        )

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,
-    )