free-claude-code 6.2.64__py3-none-any.whl

free_claude_code/providers/github_copilot/broker.py

@@ -0,0 +1,248 @@
+"""Account-scoped discovery and inert endpoint sessions with draining leases."""
+
+import asyncio
+import time
+from collections.abc import AsyncIterator, Mapping
+from contextlib import asynccontextmanager
+from dataclasses import replace
+from types import MappingProxyType
+
+from free_claude_code.application.errors import InvalidRequestError
+from free_claude_code.providers.endpoint_types import HttpEndpoint
+
+from .lifecycle import drain_owned
+from .types import (
+    CopilotAuthenticationRequired,
+    CopilotEgress,
+    CopilotEndpoint,
+    CopilotIdentity,
+    CopilotModel,
+    CopilotRuntime,
+    CopilotSession,
+    CopilotUnavailable,
+)
+
+_REFRESH_EARLY_SECONDS = 30
+
+
+class _EndpointOwner:
+    def __init__(self, runtime: CopilotRuntime, model_id: str) -> None:
+        self._runtime = runtime
+        self._model_id = model_id
+        self._lock = asyncio.Lock()
+        self._session_task: asyncio.Task[CopilotSession] | None = None
+        self._snapshot: CopilotEndpoint | None = None
+
+    async def endpoint(self, *, force_refresh: bool) -> CopilotEndpoint:
+        async with self._lock:
+            if self._session_task is None or (
+                self._session_task.done()
+                and (
+                    self._session_task.cancelled()
+                    or self._session_task.exception() is not None
+                )
+            ):
+                self._session_task = asyncio.create_task(
+                    self._runtime.session(self._model_id)
+                )
+            session = await asyncio.shield(self._session_task)
+            snapshot = self._snapshot
+            if (
+                force_refresh
+                or snapshot is None
+                or (
+                    snapshot.expires_at is not None
+                    and snapshot.expires_at <= time.time() + _REFRESH_EARLY_SECONDS
+                )
+            ):
+                snapshot = await session.endpoint()
+                if (
+                    snapshot.expires_at is not None
+                    and snapshot.expires_at <= time.time()
+                ):
+                    raise CopilotUnavailable(
+                        "Copilot returned an expired endpoint credential. Reconnect Copilot."
+                    )
+                self._snapshot = snapshot
+            return snapshot
+
+    async def drain_creation(self) -> None:
+        if self._session_task is not None:
+            await asyncio.gather(self._session_task, return_exceptions=True)
+
+
+class CopilotLease:
+    """Retain one concrete model and its routing family throughout inference."""
+
+    def __init__(
+        self,
+        broker: CopilotBroker,
+        owner: _EndpointOwner,
+        model: CopilotModel,
+        egress: CopilotEgress,
+    ) -> None:
+        self._broker = broker
+        self._owner = owner
+        self.model = model
+        self.egress = egress
+        self._released = False
+
+    async def endpoint(self, *, force_refresh: bool = False) -> HttpEndpoint:
+        if self._released:
+            raise CopilotUnavailable("Copilot endpoint lease has already closed.")
+        await self._broker.validate_identity()
+        self._broker.validate_model(self.model.info.model_id)
+        snapshot = await self._owner.endpoint(force_refresh=force_refresh)
+        identity = await self._broker.validate_identity()
+        self._broker.validate_model(self.model.info.model_id)
+        if snapshot.egress is not self.egress:
+            raise CopilotUnavailable(
+                "Copilot changed this model's upstream protocol. Retry the request to use its new endpoint."
+            )
+        return replace(snapshot.http, account_id=f"{identity.host}/{identity.login}")
+
+    def release(self) -> None:
+        self._released = True
+
+
+class CopilotBroker:
+    """Coalesce SDK discovery and retain sessions until every response closes."""
+
+    def __init__(
+        self,
+        runtime: CopilotRuntime,
+        *,
+        expected_identity: CopilotIdentity | None = None,
+    ) -> None:
+        self._runtime = runtime
+        self._identity = expected_identity
+        self._models: Mapping[str, CopilotModel] = MappingProxyType({})
+        self._owners: dict[str, _EndpointOwner] = {}
+        self._condition = asyncio.Condition()
+        self._start_task: asyncio.Task[None] | None = None
+        self._refresh_task: asyncio.Task[Mapping[str, CopilotModel]] | None = None
+        self._close_task: asyncio.Task[None] | None = None
+        self._closing = False
+        self._closed = False
+        self._leases = 0
+
+    @property
+    def identity(self) -> CopilotIdentity | None:
+        return self._identity
+
+    @property
+    def current_models(self) -> Mapping[str, CopilotModel]:
+        return self._models
+
+    async def _start(self) -> None:
+        async with self._condition:
+            if self._closing:
+                raise CopilotUnavailable("Copilot connection is closing.")
+            if self._start_task is None:
+                self._start_task = asyncio.create_task(self._runtime.start())
+            task = self._start_task
+        await asyncio.shield(task)
+
+    async def validate_identity(self) -> CopilotIdentity:
+        identity = await self._runtime.identity()
+        if identity is None:
+            raise CopilotAuthenticationRequired(
+                "Copilot is signed out. Connect your GitHub account in Admin."
+            )
+        if self._identity is not None and identity != self._identity:
+            raise CopilotAuthenticationRequired(
+                "The selected GitHub profile changed. Reconnect Copilot in Admin."
+            )
+        self._identity = identity
+        return identity
+
+    async def snapshot(self, *, refresh: bool = False) -> Mapping[str, CopilotModel]:
+        await self._start()
+        await self.validate_identity()
+        async with self._condition:
+            if self._closing:
+                raise CopilotUnavailable("Copilot connection is closing.")
+            task = self._refresh_task
+            if task is None or task.done():
+                if self._models and not refresh:
+                    return self._models
+                task = asyncio.create_task(self._discover())
+                self._refresh_task = task
+        return await asyncio.shield(task)
+
+    def validate_model(self, model_id: str) -> CopilotModel:
+        model = self._models.get(model_id)
+        if model is None:
+            raise InvalidRequestError(
+                "This model is not available from the connected Copilot account. Refresh the model list."
+            )
+        return model
+
+    async def _discover(self) -> Mapping[str, CopilotModel]:
+        await self.validate_identity()
+        models = await self._runtime.models()
+        await self.validate_identity()
+        result = {model.info.model_id: model for model in models}
+        if len(result) != len(models):
+            raise CopilotUnavailable("Copilot returned conflicting model identifiers.")
+        async with self._condition:
+            if self._closing:
+                raise CopilotUnavailable("Copilot connection closed during discovery.")
+            self._models = MappingProxyType(result)
+            if not result:
+                raise CopilotUnavailable(
+                    "This GitHub account exposes no enabled Copilot models. Check its subscription and model policies."
+                )
+            return self._models
+
+    @asynccontextmanager
+    async def lease(self, model_id: str) -> AsyncIterator[CopilotLease]:
+        await self.snapshot()
+        async with self._condition:
+            if self._closing:
+                raise CopilotUnavailable("Copilot connection is closing.")
+            model = self.validate_model(model_id)
+            self._leases += 1
+            owner = self._owners.get(model_id)
+            if owner is None:
+                owner = _EndpointOwner(self._runtime, model_id)
+                self._owners[model_id] = owner
+        lease = None
+        try:
+            await self.validate_identity()
+            endpoint = await owner.endpoint(force_refresh=False)
+            await self.validate_identity()
+            self.validate_model(model_id)
+            lease = CopilotLease(self, owner, model, endpoint.egress)
+            yield lease
+        finally:
+            if lease is not None:
+                lease.release()
+            async with self._condition:
+                self._leases -= 1
+                self._condition.notify_all()
+
+    async def close(self) -> None:
+        if self._closed:
+            return
+        if self._close_task is None or self._close_task.done():
+            self._closing = True
+            self._close_task = asyncio.create_task(self._close())
+        await drain_owned(self._close_task)
+
+    async def _close(self) -> None:
+        # Stop discovery publication; SDK-owned work itself has bounded RPC timeouts.
+        tasks = [
+            task for task in (self._start_task, self._refresh_task) if task is not None
+        ]
+        if tasks:
+            await asyncio.gather(*tasks, return_exceptions=True)
+        async with self._condition:
+            await self._condition.wait_for(lambda: self._leases == 0)
+        await asyncio.gather(
+            *(owner.drain_creation() for owner in self._owners.values())
+        )
+        await self._runtime.close()
+        self._owners.clear()
+        self._models = MappingProxyType({})
+        self._closed = True

free_claude_code/providers/github_copilot/lifecycle.py

@@ -0,0 +1,18 @@
+"""Drain Copilot-owned work before propagating caller cancellation."""
+
+import asyncio
+
+
+async def drain_owned[T](task: asyncio.Task[T]) -> T:
+    cancelled = False
+    while not task.done():
+        try:
+            await asyncio.shield(task)
+        except asyncio.CancelledError:
+            if task.cancelled():
+                raise
+            cancelled = True
+    result = task.result()
+    if cancelled:
+        raise asyncio.CancelledError
+    return result

free_claude_code/providers/github_copilot/login.py

@@ -0,0 +1,112 @@
+"""Official native Copilot device login; FCC never handles the resulting token."""
+
+import asyncio
+import os
+import re
+import subprocess
+from collections.abc import Callable
+from contextlib import suppress
+from dataclasses import dataclass
+from urllib.parse import urlsplit
+
+from .lifecycle import drain_owned
+from .native_cli import profile_environment, verified_cli_path
+from .types import CopilotUnavailable
+
+LOGIN_TIMEOUT_SECONDS = 15 * 60
+_CHALLENGE = re.compile(
+    r"visit\s+(https://[^\s]+/login/device)\s+and enter code\s+([A-Z0-9]{4}-[A-Z0-9]{4})",
+    re.IGNORECASE,
+)
+
+
+@dataclass(frozen=True, slots=True)
+class DeviceChallenge:
+    verification_url: str
+    user_code: str
+
+
+def parse_challenge(text: str) -> DeviceChallenge | None:
+    match = _CHALLENGE.search(text)
+    if match is None:
+        return None
+    url, code = match.groups()
+    parsed = urlsplit(url)
+    if not parsed.hostname or parsed.username or parsed.password:
+        return None
+    return DeviceChallenge(url, code.upper())
+
+
+async def device_login(on_challenge: Callable[[DeviceChallenge], None]) -> None:
+    """Run the pinned CLI login and own its child and both bounded readers."""
+    env = profile_environment()
+    path = await verified_cli_path(env)
+    spawning = asyncio.create_task(
+        asyncio.create_subprocess_exec(
+            path,
+            "login",
+            "--device-code",
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            env=env,
+            creationflags=subprocess.CREATE_NO_WINDOW if os.name == "nt" else 0,
+        )
+    )
+    readers: list[asyncio.Task[None]] = []
+
+    async def read_output(stream: asyncio.StreamReader) -> None:
+        buffer = ""
+        previous: DeviceChallenge | None = None
+        while chunk := await stream.read(1024):
+            buffer = (buffer + chunk.decode("utf-8", errors="replace"))[-4096:]
+            challenge = parse_challenge(buffer)
+            if challenge is not None and challenge != previous:
+                on_challenge(challenge)
+                previous = challenge
+
+    async def cleanup() -> None:
+        try:
+            process = await spawning
+        except Exception:
+            return
+        # Cancellation can arrive before normal readers are installed, or cancel
+        # their gather. Pipe transports must finish before process.wait can settle.
+        for reader in readers:
+            reader.cancel()
+        await asyncio.gather(*readers, return_exceptions=True)
+
+        async def discard(stream: asyncio.StreamReader) -> None:
+            while await stream.read(65536):
+                pass
+
+        draining = [
+            asyncio.create_task(discard(stream))
+            for stream in (process.stdout, process.stderr)
+            if stream is not None
+        ]
+        try:
+            if process.returncode is None:
+                with suppress(ProcessLookupError):
+                    process.kill()
+            await process.wait()
+        finally:
+            await asyncio.gather(*draining)
+
+    try:
+        process = await asyncio.shield(spawning)
+        if process.stdout is None or process.stderr is None:
+            raise CopilotUnavailable("Copilot login output is unavailable.")
+        readers.extend(
+            (
+                asyncio.create_task(read_output(process.stdout)),
+                asyncio.create_task(read_output(process.stderr)),
+            )
+        )
+        code = await process.wait()
+        await asyncio.gather(*readers)
+        if code != 0:
+            raise CopilotUnavailable(
+                "Copilot sign-in did not complete. Retry Connect or run copilot login --device-code."
+            )
+    finally:
+        await drain_owned(asyncio.create_task(cleanup()))

free_claude_code/providers/github_copilot/native_cli.py

@@ -0,0 +1,82 @@
+"""Native Copilot CLI checks without importing the Copilot SDK."""
+
+import asyncio
+import os
+import re
+import shutil
+import subprocess
+from collections.abc import Mapping
+from contextlib import suppress
+
+from .lifecycle import drain_owned
+from .types import CopilotUnavailable
+
+COPILOT_CLI_VERSION = "1.0.83"
+
+
+_TOKEN_ENV = frozenset(
+    {
+        "COPILOT_GITHUB_TOKEN",
+        "GH_TOKEN",
+        "GITHUB_TOKEN",
+        "GITHUB_COPILOT_API_TOKEN",
+        "COPILOT_API_URL",
+        "COPILOT_SDK_AUTH_TOKEN",
+        "COPILOT_DISABLE_KEYTAR",
+        "COPILOT_OFFLINE",
+    }
+)
+
+
+def profile_environment(source: Mapping[str, str] | None = None) -> dict[str, str]:
+    """Keep native profile selection while excluding token and BYOK overrides."""
+    return {
+        key: value
+        for key, value in (os.environ if source is None else source).items()
+        if key.upper() not in _TOKEN_ENV
+        and not key.upper().startswith("COPILOT_PROVIDER_")
+    }
+
+
+async def verified_cli_path(env: Mapping[str, str]) -> str:
+    path = shutil.which("copilot", path=env.get("PATH"))
+    if path is None:
+        raise CopilotUnavailable(
+            f"Install GitHub Copilot CLI {COPILOT_CLI_VERSION}, then connect again."
+        )
+    process = await asyncio.create_subprocess_exec(
+        path,
+        "--version",
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+        env=env,
+        creationflags=subprocess.CREATE_NO_WINDOW if os.name == "nt" else 0,
+    )
+    try:
+        async with asyncio.timeout(15):
+            stdout, _ = await process.communicate()
+    except TimeoutError:
+        raise CopilotUnavailable(
+            "Copilot CLI did not report its version in time. Check the CLI installation and reconnect."
+        ) from None
+    finally:
+        if process.returncode is None:
+            await drain_owned(asyncio.create_task(_close_cli_probe(process)))
+    if (
+        process.returncode != 0
+        or re.match(
+            rf"GitHub Copilot CLI {re.escape(COPILOT_CLI_VERSION)}\.?(?:\r?\n|\Z)",
+            stdout.decode("utf-8", errors="replace"),
+        )
+        is None
+    ):
+        raise CopilotUnavailable(
+            f"FCC requires GitHub Copilot CLI {COPILOT_CLI_VERSION} for its pinned SDK. Install that version and reconnect."
+        )
+    return path
+
+
+async def _close_cli_probe(process: asyncio.subprocess.Process) -> None:
+    with suppress(ProcessLookupError):
+        process.kill()
+    await process.communicate()