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

ccproxy/plugins/copilot/detection_service.py

@@ -0,0 +1,255 @@
+"""GitHub CLI detection service for Copilot plugin."""
+
+import asyncio
+import shutil
+from datetime import datetime, timedelta
+from typing import TYPE_CHECKING, Any, cast
+
+from ccproxy.config.settings import Settings
+from ccproxy.core.logging import get_plugin_logger
+
+from .models import CopilotCacheData, CopilotCliInfo
+
+
+if TYPE_CHECKING:
+    from ccproxy.services.cli_detection import CLIDetectionService
+
+
+logger = get_plugin_logger()
+
+
+class CopilotDetectionService:
+    """GitHub CLI detection and capability discovery service."""
+
+    def __init__(self, settings: Settings, cli_service: "CLIDetectionService"):
+        """Initialize detection service.
+
+        Args:
+            settings: Application settings
+            cli_service: Core CLI detection service
+        """
+        self.settings = settings
+        self._cli_service = cli_service
+        self._cache: CopilotCacheData | None = None
+        self._cache_ttl = timedelta(minutes=5)  # Cache for 5 minutes
+
+    async def initialize_detection(self) -> CopilotCacheData:
+        """Initialize GitHub CLI detection and cache results.
+
+        Returns:
+            Cached detection data
+        """
+        if self._cache and not self._is_cache_expired():
+            logger.debug(
+                "using_cached_detection_data",
+                cache_age=(datetime.now() - self._cache.last_check).total_seconds(),
+            )
+            return self._cache
+
+        logger.debug("initializing_github_cli_detection")
+
+        # Check if GitHub CLI is available
+        cli_path = self.get_cli_path()
+        cli_available = cli_path is not None
+
+        cli_version = None
+        auth_status = None
+        username = None
+
+        if cli_available and cli_path:
+            try:
+                # Get CLI version
+                version_result = await asyncio.create_subprocess_exec(
+                    *cli_path,
+                    "--version",
+                    stdout=asyncio.subprocess.PIPE,
+                    stderr=asyncio.subprocess.PIPE,
+                )
+                stdout, stderr = await version_result.communicate()
+
+                if version_result.returncode == 0:
+                    version_output = stdout.decode().strip()
+                    # Parse version from "gh version 2.x.x" format
+                    for line in version_output.split("\n"):
+                        if line.startswith("gh version"):
+                            cli_version = (
+                                line.split()[2] if len(line.split()) >= 3 else None
+                            )
+                            break
+
+                # Check authentication status
+                auth_result = await asyncio.create_subprocess_exec(
+                    *cli_path,
+                    "auth",
+                    "status",
+                    stdout=asyncio.subprocess.PIPE,
+                    stderr=asyncio.subprocess.PIPE,
+                )
+                stdout, stderr = await auth_result.communicate()
+
+                if auth_result.returncode == 0:
+                    auth_status = "authenticated"
+                    auth_output = (
+                        stderr.decode() + stdout.decode()
+                    )  # gh auth status uses stderr
+
+                    # Extract username from output
+                    for line in auth_output.split("\n"):
+                        if "Logged in to github.com as" in line:
+                            parts = line.split()
+                            if len(parts) >= 6:
+                                username = parts[5].strip()
+                                break
+                else:
+                    auth_status = "not_authenticated"
+
+            except Exception as e:
+                logger.warning(
+                    "github_cli_check_failed",
+                    error=str(e),
+                    exc_info=e,
+                )
+                auth_status = "check_failed"
+
+        # Update cache
+        self._cache = CopilotCacheData(
+            cli_available=cli_available,
+            cli_version=cli_version,
+            auth_status=auth_status,
+            username=username,
+            last_check=datetime.now(),
+        )
+
+        logger.debug(
+            "github_cli_detection_completed",
+            cli_available=cli_available,
+            cli_version=cli_version,
+            auth_status=auth_status,
+            username=username,
+        )
+
+        return self._cache
+
+    def get_cli_path(self) -> list[str] | None:
+        """Get GitHub CLI command path.
+
+        Returns:
+            CLI command as list of strings, or None if not available
+        """
+        # Try to find GitHub CLI
+        cli_binary = shutil.which("gh")
+        if cli_binary:
+            return [cli_binary]
+
+        logger.debug("github_cli_not_found")
+        return None
+
+    def get_cli_health_info(self) -> CopilotCliInfo:
+        """Get GitHub CLI health information.
+
+        Returns:
+            CLI health information
+        """
+        if not self._cache:
+            return CopilotCliInfo(
+                available=False,
+                version=None,
+                authenticated=False,
+                username=None,
+                error="Detection not initialized - call initialize_detection() first",
+            )
+
+        return CopilotCliInfo(
+            available=self._cache.cli_available,
+            version=self._cache.cli_version,
+            authenticated=self._cache.auth_status == "authenticated",
+            username=self._cache.username,
+            error=None if self._cache.cli_available else "GitHub CLI not found in PATH",
+        )
+
+    def _is_cache_expired(self) -> bool:
+        """Check if detection cache has expired.
+
+        Returns:
+            True if cache is expired
+        """
+        if not self._cache:
+            return True
+
+        return datetime.now() - self._cache.last_check > self._cache_ttl
+
+    async def refresh_cache(self) -> CopilotCacheData:
+        """Force refresh of detection cache.
+
+        Returns:
+            Fresh detection data
+        """
+        logger.debug("forcing_detection_cache_refresh")
+        self._cache = None
+        return await self.initialize_detection()
+
+    def get_recommended_headers(self) -> dict[str, str]:
+        """Get recommended headers for Copilot API requests.
+
+        Returns:
+            Dictionary of headers
+        """
+        headers = {
+            "Content-Type": "application/json",
+            "Copilot-Integration-Id": "vscode-chat",
+            "Editor-Version": "vscode/1.85.0",
+            "Editor-Plugin-Version": "copilot-chat/0.26.7",
+            "User-Agent": "GitHubCopilotChat/0.26.7",
+            "X-GitHub-Api-Version": "2025-04-01",
+        }
+
+        # Add CLI version if available
+        if self._cache and self._cache.cli_version:
+            headers["X-GitHub-CLI-Version"] = self._cache.cli_version
+
+        return headers
+
+    async def validate_environment(self) -> dict[str, Any]:
+        """Validate the environment for Copilot usage.
+
+        Returns:
+            Validation results with status and details
+        """
+        await self.initialize_detection()
+
+        validation = {
+            "status": "healthy",
+            "details": {
+                "github_cli": {
+                    "available": self._cache.cli_available if self._cache else False,
+                    "version": self._cache.cli_version if self._cache else None,
+                    "authenticated": (
+                        self._cache.auth_status == "authenticated"
+                        if self._cache
+                        else False
+                    ),
+                    "username": self._cache.username if self._cache else None,
+                },
+                "last_check": self._cache.last_check.isoformat()
+                if self._cache
+                else None,
+            },
+        }
+
+        # Determine overall health
+        issues: list[str] = []
+        details = cast(dict[str, Any], validation["details"])
+        github_cli = cast(dict[str, Any], details["github_cli"])
+
+        if not github_cli["available"]:
+            issues.append("GitHub CLI not available")
+        if not github_cli["authenticated"]:
+            issues.append("GitHub CLI not authenticated")
+        if not details["copilot_access"]:
+            issues.append("No Copilot access detected")
+
+        if issues:
+            validation["status"] = "unhealthy"
+            validation["issues"] = issues
+
+        return validation

ccproxy/plugins/copilot/manager.py

@@ -0,0 +1,275 @@
+"""Copilot token manager implementation."""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime
+from time import time
+from typing import Any
+
+import httpx
+
+from ccproxy.auth.managers.base import BaseTokenManager
+from ccproxy.auth.managers.token_snapshot import TokenSnapshot
+from ccproxy.auth.oauth.protocol import StandardProfileFields
+from ccproxy.auth.storage.base import TokenStorage
+from ccproxy.core.logging import get_plugin_logger
+
+from .config import CopilotOAuthConfig
+from .oauth.client import CopilotOAuthClient
+from .oauth.models import CopilotCredentials
+from .oauth.storage import CopilotOAuthStorage
+
+
+logger = get_plugin_logger()
+
+
+class CopilotTokenManager(BaseTokenManager[CopilotCredentials]):
+    """Manager for GitHub Copilot credential lifecycle."""
+
+    def __init__(
+        self,
+        storage: TokenStorage[CopilotCredentials] | None = None,
+        *,
+        config: CopilotOAuthConfig | None = None,
+        http_client: httpx.AsyncClient | None = None,
+        hook_manager: Any | None = None,
+        detection_service: Any | None = None,
+    ) -> None:
+        storage = storage or CopilotOAuthStorage()
+        super().__init__(storage)
+        self.config = config or CopilotOAuthConfig()
+        self._client = CopilotOAuthClient(
+            self.config,
+            storage
+            if isinstance(storage, CopilotOAuthStorage)
+            else CopilotOAuthStorage(),
+            http_client=http_client,
+            hook_manager=hook_manager,
+            detection_service=detection_service,
+        )
+        self._profile_cache: StandardProfileFields | None = None
+
+    @classmethod
+    async def create(
+        cls,
+        storage: TokenStorage[CopilotCredentials] | None = None,
+        *,
+        config: CopilotOAuthConfig | None = None,
+        http_client: httpx.AsyncClient | None = None,
+        hook_manager: Any | None = None,
+        detection_service: Any | None = None,
+    ) -> CopilotTokenManager:
+        """Async factory for parity with other managers."""
+        return cls(
+            storage=storage,
+            config=config,
+            http_client=http_client,
+            hook_manager=hook_manager,
+            detection_service=detection_service,
+        )
+
+    def _build_token_snapshot(self, credentials: CopilotCredentials) -> TokenSnapshot:
+        """Construct a token snapshot for Copilot credentials."""
+        access_token: str | None = None
+        copilot_token = credentials.copilot_token
+        if copilot_token and copilot_token.token:
+            access_token = copilot_token.token.get_secret_value()
+
+        refresh_token: str | None = None
+        oauth_token = credentials.oauth_token
+        if oauth_token.refresh_token:
+            refresh_token = oauth_token.refresh_token.get_secret_value()
+
+        expires_at = None
+        if copilot_token and copilot_token.expires_at:
+            expires_at = copilot_token.expires_at
+        else:
+            if oauth_token.expires_in and oauth_token.created_at:
+                expires_at = oauth_token.expires_at_datetime
+
+        scope_value = oauth_token.scope or ""
+        scopes = tuple(
+            scope
+            for scope in (item.strip() for item in scope_value.split(" "))
+            if scope
+        )
+
+        extras = {
+            "account_type": credentials.account_type,
+            "has_copilot_token": bool(credentials.copilot_token),
+        }
+
+        logger.debug(
+            "copilot_token_snapshot",
+            scopes=scopes,
+            expires_at=expires_at,
+            credentials=credentials,
+            access_token=access_token,
+            refresh_token=refresh_token,
+        )
+        return TokenSnapshot(
+            provider="copilot",
+            access_token=access_token,
+            refresh_token=refresh_token,
+            expires_at=expires_at,
+            scopes=scopes,
+            extras=extras,
+        )
+
+    # ==================================================================
+    # BaseTokenManager protocol implementations
+    # ==================================================================
+
+    async def refresh_token(self) -> CopilotCredentials | None:
+        credentials = await self.load_credentials()
+        if not credentials:
+            logger.error("copilot_refresh_no_credentials", category="auth")
+            return None
+
+        try:
+            refreshed = await self._client.refresh_copilot_token(credentials)
+            # Client already persisted credentials; refresh in-memory caches.
+            self._credentials_cache = refreshed
+            self._credentials_loaded_at = time()
+            self._auth_cache.clear()
+            self._profile_cache = None
+            return refreshed
+        except Exception as exc:  # pragma: no cover - defensive logging
+            logger.error(
+                "copilot_refresh_failed",
+                error=str(exc),
+                exc_info=exc,
+                category="auth",
+            )
+            return None
+
+    def is_expired(self, credentials: CopilotCredentials) -> bool:
+        token = credentials.copilot_token
+        if not token:
+            return True
+
+        now = datetime.now(UTC)
+        if token.expires_at and now >= token.expires_at:
+            return True
+
+        refresh_deadline = self._compute_refresh_deadline(credentials)
+        if refresh_deadline and now >= refresh_deadline:
+            return True
+
+        return credentials.oauth_token.is_expired
+
+    def get_account_id(self, credentials: CopilotCredentials) -> str | None:
+        # GitHub account information is part of profile, not raw credentials.
+        return None
+
+    def get_expiration_time(self, credentials: CopilotCredentials) -> datetime | None:
+        candidates: list[datetime] = []
+
+        token = credentials.copilot_token
+        if token:
+            if token.expires_at:
+                candidates.append(token.expires_at)
+
+            refresh_deadline = self._compute_refresh_deadline(credentials)
+            if refresh_deadline:
+                candidates.append(refresh_deadline)
+
+        if credentials.oauth_token.expires_in and credentials.oauth_token.created_at:
+            candidates.append(credentials.oauth_token.expires_at_datetime)
+
+        if not candidates:
+            return None
+
+        return min(candidates)
+
+    # ==================================================================
+    # Token access helpers used by adapters/routes
+    # ==================================================================
+
+    async def ensure_copilot_token(self) -> str:
+        credentials = await self.load_credentials()
+        if not credentials:
+            raise ValueError("No Copilot credentials available")
+
+        if credentials.oauth_token.is_expired:
+            raise ValueError("OAuth token expired; re-authentication required")
+
+        if not credentials.copilot_token or credentials.copilot_token.is_expired:
+            logger.debug("copilot_token_refresh_needed", category="auth")
+            credentials = await self._client.refresh_copilot_token(credentials)
+            self._credentials_cache = credentials
+            self._credentials_loaded_at = time()
+            self._auth_cache.clear()
+            self._profile_cache = None
+
+        token = credentials.copilot_token
+        if not token:
+            raise ValueError("Unable to obtain Copilot service token")
+        return token.token.get_secret_value()
+
+    async def ensure_oauth_token(self) -> str:
+        credentials = await self.load_credentials()
+        if not credentials:
+            raise ValueError("No Copilot credentials available")
+        if credentials.oauth_token.is_expired:
+            raise ValueError("OAuth token expired; re-authentication required")
+        return credentials.oauth_token.access_token.get_secret_value()
+
+    async def get_access_token(self) -> str | None:
+        try:
+            return await self.ensure_copilot_token()
+        except Exception as exc:
+            logger.error(
+                "copilot_access_token_failed",
+                error=str(exc),
+                category="auth",
+            )
+            return None
+
+    async def get_access_token_with_refresh(self) -> str | None:
+        return await self.get_access_token()
+
+    async def get_profile(self) -> StandardProfileFields | None:
+        if self._profile_cache:
+            return self._profile_cache
+        credentials = await self.load_credentials()
+        if not credentials:
+            return None
+        try:
+            profile = await self._client.get_standard_profile(credentials.oauth_token)
+        except Exception as exc:  # pragma: no cover - defensive logging
+            logger.debug("copilot_profile_fetch_failed", error=str(exc))
+            return None
+        self._profile_cache = profile
+        return profile
+
+    async def get_profile_quick(self) -> StandardProfileFields | None:
+        return await self.get_profile()
+
+    async def aclose(self) -> None:
+        await self._client.close()
+
+    def _compute_refresh_deadline(
+        self, credentials: CopilotCredentials
+    ) -> datetime | None:
+        token = credentials.copilot_token
+        if not token or not token.refresh_in:
+            return None
+
+        try:
+            updated_at = int(credentials.updated_at)
+        except (TypeError, ValueError):
+            return None
+
+        try:
+            refresh_in = int(token.refresh_in)
+        except (TypeError, ValueError):
+            return None
+
+        if refresh_in <= 0:
+            return datetime.now(UTC)
+
+        return datetime.fromtimestamp(updated_at + refresh_in, tz=UTC)
+
+
+__all__ = ["CopilotTokenManager"]