robot-u-site/forgejo_client.py

from __future__ import annotations

import base64
from collections.abc import Mapping
from typing import Any

import httpx

from settings import Settings


class ForgejoClientError(RuntimeError):
    pass


class ForgejoClient:
    def __init__(
        self,
        settings: Settings,
        forgejo_token: str | None = None,
        auth_scheme: str = "token",
    ) -> None:
        self._settings = settings
        self._forgejo_token = forgejo_token or settings.forgejo_token
        self._auth_scheme = auth_scheme
        self._client = httpx.AsyncClient(timeout=settings.forgejo_request_timeout_seconds)

    async def __aenter__(self) -> ForgejoClient:
        return self

    async def __aexit__(self, _exc_type: object, _exc: object, _tb: object) -> None:
        await self._client.aclose()

    async def fetch_openid_configuration(self) -> dict[str, Any]:
        return await self._get_json(
            f"{self._settings.forgejo_base_url}/.well-known/openid-configuration",
            absolute_url=True,
        )

    async def exchange_oauth_code(
        self,
        *,
        token_endpoint: str,
        client_id: str,
        client_secret: str,
        code: str,
        redirect_uri: str,
        code_verifier: str,
    ) -> dict[str, Any]:
        response = await self._client.post(
            token_endpoint,
            data={
                "grant_type": "authorization_code",
                "client_id": client_id,
                "client_secret": client_secret,
                "code": code,
                "redirect_uri": redirect_uri,
                "code_verifier": code_verifier,
            },
            headers={"Accept": "application/json"},
        )
        if response.is_success:
            payload = response.json()
            if isinstance(payload, dict):
                return payload
            raise ForgejoClientError("Unexpected Forgejo OAuth token payload.")

        message = self._extract_error_message(response)
        raise ForgejoClientError(f"{response.status_code} from Forgejo OAuth: {message}")

    async def fetch_userinfo(self, userinfo_endpoint: str, access_token: str) -> dict[str, Any]:
        response = await self._client.get(
            userinfo_endpoint,
            headers={
                "Accept": "application/json",
                "Authorization": f"Bearer {access_token}",
            },
        )
        if response.is_success:
            payload = response.json()
            if isinstance(payload, dict):
                return payload
            raise ForgejoClientError("Unexpected Forgejo UserInfo payload.")

        message = self._extract_error_message(response)
        raise ForgejoClientError(f"{response.status_code} from Forgejo UserInfo: {message}")

    async def fetch_current_user(self) -> dict[str, Any]:
        return await self._get_json("/api/v1/user", auth_required=True)

    async def search_repositories(self) -> list[dict[str, Any]]:
        scan_limit = max(self._settings.forgejo_repo_scan_limit, 1)
        page_limit = min(scan_limit, 50)
        repos: list[dict[str, Any]] = []
        page = 1

        while len(repos) < scan_limit:
            payload = await self._get_json(
                "/api/v1/repos/search",
                params={
                    "limit": page_limit,
                    "page": page,
                    "private": "false",
                    "is_private": "false",
                },
            )
            if not isinstance(payload, dict):
                break

            data = payload.get("data", [])
            page_repos = [repo for repo in data if isinstance(repo, dict)]
            repos.extend(page_repos)
            if len(page_repos) < page_limit:
                break
            page += 1

        return repos[:scan_limit]

    async def fetch_repository(self, owner: str, repo: str) -> dict[str, Any]:
        payload = await self._get_json(
            f"/api/v1/repos/{owner}/{repo}",
        )
        if isinstance(payload, dict):
            return payload
        raise ForgejoClientError(f"Unexpected repository payload for {owner}/{repo}")

    async def list_repo_issues(
        self,
        owner: str,
        repo: str,
        *,
        limit: int,
    ) -> list[dict[str, Any]]:
        payload = await self._get_json(
            f"/api/v1/repos/{owner}/{repo}/issues",
            params={
                "state": "open",
                "page": 1,
                "limit": limit,
                "type": "issues",
                "sort": "recentupdate",
            },
        )
        if isinstance(payload, list):
            return [issue for issue in payload if isinstance(issue, dict)]
        return []

    async def fetch_issue(self, owner: str, repo: str, issue_number: int) -> dict[str, Any]:
        payload = await self._get_json(f"/api/v1/repos/{owner}/{repo}/issues/{issue_number}")
        if isinstance(payload, dict):
            return payload
        raise ForgejoClientError(f"Unexpected issue payload for {owner}/{repo}#{issue_number}")

    async def list_directory(self, owner: str, repo: str, path: str = "") -> list[dict[str, Any]]:
        endpoint = f"/api/v1/repos/{owner}/{repo}/contents"
        if path:
            endpoint = f"{endpoint}/{path.strip('/')}"

        payload = await self._get_json(endpoint)
        if isinstance(payload, list):
            return [entry for entry in payload if isinstance(entry, dict)]
        if isinstance(payload, dict):
            return [payload]
        return []

    async def list_issue_comments(
        self,
        owner: str,
        repo: str,
        issue_number: int,
    ) -> list[dict[str, Any]]:
        payload = await self._get_json(
            f"/api/v1/repos/{owner}/{repo}/issues/{issue_number}/comments",
        )
        if isinstance(payload, list):
            return [comment for comment in payload if isinstance(comment, dict)]
        return []

    async def create_issue_comment(
        self,
        owner: str,
        repo: str,
        issue_number: int,
        body: str,
    ) -> dict[str, Any]:
        payload = await self._request_json(
            "POST",
            f"/api/v1/repos/{owner}/{repo}/issues/{issue_number}/comments",
            json_payload={"body": body},
            auth_required=True,
        )
        if isinstance(payload, dict):
            return payload
        raise ForgejoClientError(f"Unexpected comment payload for {owner}/{repo}#{issue_number}")

    async def create_issue(
        self,
        owner: str,
        repo: str,
        title: str,
        body: str,
        label_ids: list[int] | None = None,
    ) -> dict[str, Any]:
        payload_data: dict[str, object] = {"title": title, "body": body}
        if label_ids:
            payload_data["labels"] = label_ids

        payload = await self._request_json(
            "POST",
            f"/api/v1/repos/{owner}/{repo}/issues",
            json_payload=payload_data,
            auth_required=True,
        )
        if isinstance(payload, dict):
            return payload
        raise ForgejoClientError(f"Unexpected issue payload for {owner}/{repo}")

    async def ensure_repo_label(
        self,
        owner: str,
        repo: str,
        name: str,
        *,
        color: str,
        description: str,
    ) -> int:
        for label in await self.list_repo_labels(owner, repo):
            if str(label.get("name", "")).strip().casefold() != name.casefold():
                continue

            label_id = int(label.get("id", 0) or 0)
            if label_id > 0:
                return label_id

        label = await self.create_repo_label(
            owner, repo, name, color=color, description=description
        )
        label_id = int(label.get("id", 0) or 0)
        if label_id <= 0:
            raise ForgejoClientError(f"Forgejo did not return an id for label {name!r}.")
        return label_id

    async def list_repo_labels(self, owner: str, repo: str) -> list[dict[str, Any]]:
        payload = await self._get_json(
            f"/api/v1/repos/{owner}/{repo}/labels",
            params={"page": 1, "limit": 100},
            auth_required=True,
        )
        if isinstance(payload, list):
            return [label for label in payload if isinstance(label, dict)]
        return []

    async def create_repo_label(
        self,
        owner: str,
        repo: str,
        name: str,
        *,
        color: str,
        description: str,
    ) -> dict[str, Any]:
        payload = await self._request_json(
            "POST",
            f"/api/v1/repos/{owner}/{repo}/labels",
            json_payload={"name": name, "color": color, "description": description},
            auth_required=True,
        )
        if isinstance(payload, dict):
            return payload
        raise ForgejoClientError(f"Unexpected label payload for {owner}/{repo}")

    async def get_file_content(self, owner: str, repo: str, path: str) -> dict[str, str]:
        payload = await self._get_json(
            f"/api/v1/repos/{owner}/{repo}/contents/{path.strip('/')}",
        )
        if not isinstance(payload, dict):
            raise ForgejoClientError(f"Unexpected file payload for {owner}/{repo}:{path}")

        raw_content = payload.get("content", "")
        encoding = payload.get("encoding", "")
        decoded_content = ""
        if isinstance(raw_content, str):
            if encoding == "base64":
                decoded_content = base64.b64decode(raw_content).decode("utf-8")
            else:
                decoded_content = raw_content

        return {
            "name": str(payload.get("name", "")),
            "path": str(payload.get("path", path)),
            "html_url": str(payload.get("html_url", "")),
            "content": decoded_content,
        }

    async def _get_json(
        self,
        path: str,
        *,
        absolute_url: bool = False,
        params: Mapping[str, str | int] | None = None,
        auth_required: bool = False,
    ) -> dict[str, Any] | list[Any]:
        return await self._request_json(
            "GET",
            path,
            absolute_url=absolute_url,
            params=params,
            auth_required=auth_required,
        )

    async def _request_json(
        self,
        method: str,
        path: str,
        *,
        absolute_url: bool = False,
        params: Mapping[str, str | int] | None = None,
        json_payload: Mapping[str, object] | None = None,
        auth_required: bool = False,
    ) -> dict[str, Any] | list[Any]:
        if auth_required and not self._forgejo_token:
            raise ForgejoClientError(
                "This Forgejo instance requires an authenticated API token for repo and issue access.",
            )

        url = path if absolute_url else f"{self._settings.forgejo_base_url}{path}"
        headers = {}
        if self._forgejo_token:
            scheme = "Bearer" if self._auth_scheme.casefold() == "bearer" else "token"
            headers["Authorization"] = f"{scheme} {self._forgejo_token}"

        response = await self._client.request(
            method,
            url,
            params=params,
            headers=headers,
            json=json_payload,
        )
        if response.is_success:
            return response.json()

        message = self._extract_error_message(response)
        raise ForgejoClientError(f"{response.status_code} from Forgejo: {message}")

    @staticmethod
    def _extract_error_message(response: httpx.Response) -> str:
        try:
            payload = response.json()
        except ValueError:
            return response.text or response.reason_phrase

        if isinstance(payload, dict):
            raw_message = payload.get("message")
            if isinstance(raw_message, str) and raw_message:
                return raw_message
        return response.reason_phrase