from __future__ import annotations """Opt-in FCC connection state over native Copilot account credentials.""" import asyncio import json import os import tempfile import time import uuid from collections.abc import AsyncGenerator, Awaitable, Callable, Mapping from contextlib import asynccontextmanager from pathlib import Path from free_claude_code.application.connected_accounts import ( ConnectedAccountLoginMode, ConnectedAccountState, ConnectedAccountStatus, ) from free_claude_code.application.errors import InvalidRequestError from free_claude_code.config.paths import github_copilot_auth_path from free_claude_code.core.async_tasks import run_sync_owned from free_claude_code.core.failures import ExecutionFailure, FailureKind from free_claude_code.core.json_types import JsonObject from free_claude_code.providers.endpoint_types import HttpEndpoint from .broker import CopilotBroker, CopilotLease from .lifecycle import drain_owned from .login import LOGIN_TIMEOUT_SECONDS, DeviceChallenge, device_login from .types import ( CopilotAuthenticationRequired, CopilotEgress, CopilotIdentity, CopilotModel, CopilotRuntime, CopilotUnavailable, ) LoginFlow = Callable[[Callable[[DeviceChallenge], None]], Awaitable[None]] async def _create_sdk_runtime() -> CopilotRuntime: def load(): from .sdk import SdkRuntime return SdkRuntime runtime_type = await run_sync_owned(load) return runtime_type() class AuthenticatedLease: """Map account loss at credential resolution to a canonical provider failure.""" def __init__( self, manager: CopilotAuthManager, broker: CopilotBroker, lease: CopilotLease, revision: int, ) -> None: self._manager = manager self._broker = broker self._lease = lease self._revision = revision @property def model(self) -> CopilotModel: return self._lease.model @property def egress(self) -> CopilotEgress: return self._lease.egress async def endpoint(self, *, force_refresh: bool = False) -> HttpEndpoint: try: self._manager.ensure_current(self._broker, self._revision) endpoint = await self._lease.endpoint(force_refresh=force_refresh) self._manager.ensure_current(self._broker, self._revision) return endpoint except CopilotUnavailable as error: raise self._manager.account_failure( error, self._broker, self._revision ) from None class CopilotAuthManager: """Own enabled state, login attempts, account revisions and draining brokers.""" provider_id = "github_copilot" def __init__( self, *, state_path: Path | None = None, runtime_factory: Callable[[], Awaitable[CopilotRuntime]] = _create_sdk_runtime, login_flow: LoginFlow = device_login, login_timeout_s: float = LOGIN_TIMEOUT_SECONDS, ) -> None: self._state_path = state_path or github_copilot_auth_path() self._runtime_factory = runtime_factory self._login_flow = login_flow self._login_timeout_s = login_timeout_s self._enabled = False self._identity: CopilotIdentity | None = None self._revision = 0 self._last_error: str | None = None self._broker: CopilotBroker | None = None self._owners: list[CopilotBroker] = [] self._operation_lock = asyncio.Lock() self._broker_lock = asyncio.Lock() self._login_task: asyncio.Task[None] | None = None self._cleanup_task: asyncio.Task[None] | None = None self._close_task: asyncio.Task[None] | None = None self._attempt_id: str | None = None self._challenge: DeviceChallenge | None = None self._expires_at: int | None = None self._closed = False try: self._read_state() except (OSError, ValueError, UnicodeError): self._enabled = False self._identity = None self._last_error = ( "Saved Copilot connection state is unreadable. Connect again." ) def is_connected(self) -> bool: return self._enabled and not self._closed def connected_provider_ids(self) -> tuple[str, ...]: return (self.provider_id,) if self.is_connected() else () def status(self) -> ConnectedAccountStatus: connecting = self._login_task is not None and not self._login_task.done() state = ( ConnectedAccountState.CONNECTING if connecting else ConnectedAccountState.ERROR if self._last_error else ConnectedAccountState.CONNECTED if self.is_connected() else ConnectedAccountState.DISCONNECTED ) challenge = self._challenge if connecting else None return ConnectedAccountStatus( provider_id=self.provider_id, state=state, connected=self.is_connected(), revision=self._revision, display_identity=self._identity.display if self._identity is not None else None, supported_login_modes=(ConnectedAccountLoginMode.DEVICE,), default_login_mode=ConnectedAccountLoginMode.DEVICE, attempt_id=self._attempt_id if connecting else None, mode=ConnectedAccountLoginMode.DEVICE if connecting else None, verification_url=challenge.verification_url if challenge else None, user_code=challenge.user_code if challenge else None, expires_at=self._expires_at if connecting else None, model_count=len(self._broker.current_models) if self._broker else 0, message=self._last_error, ) async def start_login( self, mode: ConnectedAccountLoginMode ) -> ConnectedAccountStatus: if mode is not ConnectedAccountLoginMode.DEVICE: raise InvalidRequestError("Copilot supports device-code login.") async with self._operation_lock: self._ensure_open() if self._login_task is not None and not self._login_task.done(): return self.status() # Reconnect stops new requests under the old revision immediately. if not self._disable(): return self.status() self._last_error = None attempt = uuid.uuid4().hex self._attempt_id = attempt self._challenge = None self._expires_at = int(time.time() + self._login_timeout_s) self._login_task = asyncio.create_task(self._complete_login(attempt)) return self.status() async def cancel_login(self) -> ConnectedAccountStatus: async with self._operation_lock: await self._cancel_login() try: await self._drain_retired() except CopilotUnavailable: self._last_error = "Copilot cleanup could not finish. Retry Connect to close the previous attempt." else: self._last_error = None return self.status() async def disconnect(self) -> ConnectedAccountStatus: async with self._operation_lock: self._ensure_open() saved = self._disable() await self._cancel_login() async with self._broker_lock: pass # Let any in-flight constructor publish its owned broker. await self._drain_retired() if saved: self._last_error = None return self.status() async def close(self) -> None: if self._close_task is None or self._close_task.done(): self._closed = True self._close_task = asyncio.create_task(self._close()) await drain_owned(self._close_task) async def _close(self) -> None: async with self._operation_lock: # Preserve opt-in on process shutdown; credentials belong to the CLI. await self._cancel_login() async with self._broker_lock: self._broker = None await self._drain_retired() def _ensure_open(self) -> None: if self._closed: raise CopilotUnavailable("Copilot account manager is closing.") async def _new_broker(self, identity: CopilotIdentity | None) -> CopilotBroker: broker = CopilotBroker( await self._runtime_factory(), expected_identity=identity ) self._owners.append(broker) return broker async def _current_broker(self) -> CopilotBroker: async with self._broker_lock: self._ensure_open() if not self._enabled: raise CopilotAuthenticationRequired( "Connect your GitHub Copilot account in Admin." ) if self._broker is None: revision = self._revision broker = await self._new_broker(self._identity) if self._closed or not self._enabled or self._revision != revision: # A newer login may own another, not-yet-published broker. try: await broker.close() except Exception as error: raise CopilotUnavailable( "Copilot cleanup could not finish. Retry disconnect." ) from error if broker in self._owners: self._owners.remove(broker) raise CopilotAuthenticationRequired( "Copilot connection changed. Retry after connecting in Admin." ) self._broker = broker return self._broker def ensure_current(self, broker: CopilotBroker, revision: int) -> None: if ( not self.is_connected() or broker is not self._broker or revision != self._revision ): raise CopilotAuthenticationRequired( "Copilot connection changed. Retry after connecting in Admin." ) async def models(self, *, refresh: bool = True) -> Mapping[str, CopilotModel]: broker: CopilotBroker | None = None revision = self._revision try: broker = await self._current_broker() models = await broker.snapshot(refresh=refresh) self.ensure_current(broker, revision) return models except CopilotUnavailable as error: raise self.account_failure(error, broker, revision) from None @asynccontextmanager async def lease(self, model_id: str) -> AsyncGenerator[AuthenticatedLease]: broker: CopilotBroker | None = None revision = self._revision try: broker = await self._current_broker() async with broker.lease(model_id) as lease: self.ensure_current(broker, revision) yield AuthenticatedLease(self, broker, lease, revision) except CopilotUnavailable as error: raise self.account_failure(error, broker, revision) from None except ExecutionFailure as error: if error.status_code == 401: self._invalidate( broker, revision, "Copilot rejected refreshed credentials. Reconnect in Admin.", ) raise def account_failure( self, error: CopilotUnavailable, broker: CopilotBroker | None, revision: int ) -> ExecutionFailure: if isinstance(error, CopilotAuthenticationRequired): self._invalidate(broker, revision, str(error)) return ExecutionFailure(FailureKind.AUTHENTICATION, 401, str(error), False) return ExecutionFailure(FailureKind.UNAVAILABLE, 503, str(error), False) def _invalidate( self, broker: CopilotBroker | None, revision: int, message: str ) -> None: if self._enabled and revision == self._revision and broker is self._broker: if not self._disable(): message += " FCC could not save the disconnected state." self._last_error = message def _disable(self) -> bool: self._enabled = False self._identity = None self._broker = None self._revision += 1 try: self._write_state(enabled=False, identity=None, revision=self._revision) except OSError: self._last_error = "FCC could not save the disconnected state. Check state-directory permissions and retry Disconnect." return False finally: self._schedule_cleanup() return True async def _cancel_login(self) -> None: task = self._login_task self._attempt_id = None self._challenge = None self._expires_at = None if task is not None: task.cancel() # The login owns its cleanup; cancellation waits for that finally block. await drain_owned(asyncio.create_task(_settle(task))) self._login_task = None def _schedule_cleanup(self) -> asyncio.Task[None]: if self._cleanup_task is None or self._cleanup_task.done(): self._cleanup_task = asyncio.create_task(self._cleanup_retired()) self._cleanup_task.add_done_callback(_retrieve_failure) return self._cleanup_task async def _drain_retired(self) -> None: while True: await drain_owned(self._schedule_cleanup()) if not any(owner is not self._broker for owner in self._owners): return async def _cleanup_retired(self) -> None: failures = False for broker in tuple(self._owners): if broker is self._broker: continue try: await broker.close() except Exception: failures = True else: if broker in self._owners: self._owners.remove(broker) if failures: raise CopilotUnavailable( "Copilot cleanup could not finish. Retry disconnect." ) async def _complete_login(self, attempt: str) -> None: broker: CopilotBroker | None = None def on_challenge(challenge: DeviceChallenge) -> None: if self._attempt_id == attempt and not self._closed: self._challenge = challenge try: async with asyncio.timeout(self._login_timeout_s): await self._drain_retired() broker = await self._new_broker(None) try: await broker.snapshot(refresh=True) except CopilotAuthenticationRequired: await broker.close() if broker in self._owners: self._owners.remove(broker) broker = None await self._login_flow(on_challenge) broker = await self._new_broker(None) await broker.snapshot(refresh=True) identity = broker.identity if identity is None: raise CopilotAuthenticationRequired( "Copilot did not report a signed-in profile." ) if self._attempt_id != attempt or self._closed: return revision = self._revision + 1 self._write_state(enabled=True, identity=identity, revision=revision) self._identity = identity self._revision = revision self._enabled = True self._broker = broker self._last_error = None except asyncio.CancelledError: raise except Exception as error: if self._attempt_id == attempt and not self._closed: self._last_error = ( "Copilot sign-in exceeded FCC's time limit. Connect again." if isinstance(error, TimeoutError) else str(error) if isinstance(error, CopilotUnavailable) else "Copilot connection failed. Check the CLI installation, selected account and FCC state-directory permissions." ) finally: if broker is not None and broker is not self._broker: try: await drain_owned(asyncio.create_task(broker.close())) except Exception: if self._attempt_id == attempt: self._last_error = ( "Copilot cleanup could not finish. Retry disconnect." ) else: if broker in self._owners: self._owners.remove(broker) if self._login_task is asyncio.current_task(): self._login_task = None self._attempt_id = None self._challenge = None self._expires_at = None def _read_state(self) -> None: try: payload: object = json.loads(self._state_path.read_text(encoding="utf-8")) except FileNotFoundError: return if not isinstance(payload, dict) or payload.get("schema_version") != 1: raise ValueError("Invalid Copilot state schema") revision = payload.get("revision") enabled = payload.get("enabled") if ( not isinstance(revision, int) or isinstance(revision, bool) or revision < 0 or not isinstance(enabled, bool) ): raise ValueError("Invalid Copilot state") identity = payload.get("identity") if enabled: if not isinstance(identity, dict): raise ValueError("Missing Copilot identity") host, login = identity.get("host"), identity.get("login") if ( not isinstance(host, str) or not host or not isinstance(login, str) or not login ): raise ValueError("Invalid Copilot identity") self._identity = CopilotIdentity(host, login) self._revision = revision self._enabled = enabled def _write_state( self, *, enabled: bool, identity: CopilotIdentity | None, revision: int ) -> None: payload: JsonObject = { "schema_version": 1, "enabled": enabled, "revision": revision, "identity": {"host": identity.host, "login": identity.login} if identity else None, } self._state_path.parent.mkdir(parents=True, exist_ok=True) temporary: Path | None = None try: with tempfile.NamedTemporaryFile( mode="w", encoding="utf-8", dir=self._state_path.parent, prefix=".copilot-", suffix=".tmp", delete=False, ) as handle: temporary = Path(handle.name) json.dump(payload, handle) handle.flush() os.fsync(handle.fileno()) os.replace(temporary, self._state_path) finally: if temporary is not None: temporary.unlink(missing_ok=True) async def _settle(task: asyncio.Task[None]) -> None: await asyncio.gather(task, return_exceptions=True) def _retrieve_failure(task: asyncio.Task[None]) -> None: if not task.cancelled(): task.exception()