mirror of
https://github.com/ZTatman/myst.git
synced 2026-11-21 12:27:59 +00:00
354 lines
11 KiB
Python
354 lines
11 KiB
Python
from __future__ import annotations
|
|
|
|
import hashlib
|
|
import re
|
|
import secrets
|
|
import uuid
|
|
from datetime import UTC, datetime
|
|
from typing import Annotated, Any, Literal
|
|
from urllib.parse import quote, urlsplit
|
|
|
|
import httpx
|
|
from fastapi import APIRouter, Depends, HTTPException, Query, Request, Response
|
|
from pydantic import AwareDatetime, BaseModel, ConfigDict, Field, ValidationError, field_validator
|
|
from sqlalchemy import select
|
|
from sqlalchemy.exc import SQLAlchemyError
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
|
|
from app.auth.pat import decrypt_pat
|
|
from app.auth.session import get_current_session
|
|
from app.config import get_app_settings
|
|
from app.deps import get_db
|
|
from app.models.app_settings import AppSettings
|
|
from app.models.grant import Grant
|
|
from app.models.session import Session as BrowserSession
|
|
from app.models.user import LinkedIdentity
|
|
from app.services import forgejo
|
|
from app.services.inspection import redact
|
|
|
|
router = APIRouter(prefix="/links", tags=["links"])
|
|
|
|
SessionDep = Annotated[BrowserSession, Depends(get_current_session)]
|
|
DatabaseDep = Annotated[AsyncSession, Depends(get_db)]
|
|
ClientDep = Annotated[httpx.AsyncClient, Depends(forgejo.get_client)]
|
|
SettingsDep = Annotated[AppSettings, Depends(get_app_settings)]
|
|
Name = Annotated[str, Field(min_length=1, max_length=255, pattern=r"^[\w.-]+$")]
|
|
|
|
|
|
class CreateLinkRequest(BaseModel):
|
|
model_config = ConfigDict(extra="forbid")
|
|
|
|
repo_owner: Name
|
|
repo_name: Name
|
|
branch: Annotated[str, Field(min_length=1, max_length=1024)]
|
|
expires_at: AwareDatetime
|
|
link_type: Literal["public"] = "public"
|
|
|
|
@field_validator("repo_owner", "repo_name")
|
|
@classmethod
|
|
def valid_name(cls, value: str) -> str:
|
|
if value in {".", ".."}:
|
|
raise ValueError("Invalid repository name or owner")
|
|
return value
|
|
|
|
@field_validator("branch")
|
|
@classmethod
|
|
def valid_branch(cls, value: str) -> str:
|
|
if (
|
|
value == "@"
|
|
or value.startswith(("/", "."))
|
|
or value.endswith(("/", "."))
|
|
or any(part.startswith(".") or part.endswith(".lock") for part in value.split("/"))
|
|
or any(s in value for s in ("..", "//", "@{"))
|
|
or re.search(r"[\x00-\x20\x7f~^:?*\[\\]", value)
|
|
):
|
|
raise ValueError("Invalid branch name")
|
|
return value
|
|
|
|
@field_validator("expires_at")
|
|
@classmethod
|
|
def future_expiration(cls, value: datetime) -> datetime:
|
|
if value <= datetime.now(UTC):
|
|
raise ValueError("Expiration must be in the future")
|
|
return value.astimezone(UTC)
|
|
|
|
|
|
class ForgejoUser(BaseModel):
|
|
model_config = ConfigDict(strict=True)
|
|
id: Annotated[int, Field(gt=0)]
|
|
login: Name
|
|
|
|
|
|
class ForgejoRepository(BaseModel):
|
|
model_config = ConfigDict(strict=True)
|
|
owner: ForgejoUser
|
|
name: Name
|
|
full_name: str
|
|
default_branch: str
|
|
private: bool
|
|
|
|
|
|
class Repository(BaseModel):
|
|
owner: str
|
|
name: str
|
|
full_name: str
|
|
default_branch: str
|
|
private: bool
|
|
|
|
|
|
class RepositoryResponse(BaseModel):
|
|
repositories: list[Repository]
|
|
page: int
|
|
limit: int
|
|
next_page: int | None
|
|
inspection: dict[str, Any] | None = None
|
|
|
|
|
|
class CreatedGrant(BaseModel):
|
|
id: uuid.UUID
|
|
user_id: uuid.UUID
|
|
repo_owner: str
|
|
repo_name: str
|
|
commit_sha: str
|
|
grant_type: Literal["public"]
|
|
created_at: datetime
|
|
expires_at: datetime
|
|
revoked_at: datetime | None
|
|
recipient_email: None
|
|
token_hash: Literal["[redacted]"] = "[redacted]"
|
|
|
|
|
|
class CreateLinkResponse(BaseModel):
|
|
created_grant: CreatedGrant
|
|
share_url: str
|
|
viewer_available: Literal[False] = False
|
|
inspection: dict[str, Any] | None = None
|
|
|
|
|
|
async def verify_identity(
|
|
db: AsyncSession,
|
|
sess: BrowserSession,
|
|
client: httpx.AsyncClient,
|
|
pat: str,
|
|
) -> tuple[ForgejoUser, dict[str, Any]]:
|
|
raw, _ = await forgejo.get(client, "user", pat, "identity")
|
|
try:
|
|
user = ForgejoUser.model_validate(raw)
|
|
except ValidationError:
|
|
raise forgejo.malformed("identity") from None
|
|
identity = await db.scalar(
|
|
select(LinkedIdentity).where(
|
|
LinkedIdentity.user_id == sess.user_id,
|
|
LinkedIdentity.provider == "forgejo",
|
|
LinkedIdentity.provider_user_id == str(user.id),
|
|
)
|
|
)
|
|
if identity is None:
|
|
raise HTTPException(
|
|
403,
|
|
detail={
|
|
"stage": "identity",
|
|
"message": "The PAT must belong to your signed-in Forgejo account.",
|
|
},
|
|
)
|
|
return user, raw
|
|
|
|
|
|
@router.get("/repositories", response_model_exclude_unset=True)
|
|
async def repositories(
|
|
response: Response,
|
|
sess: SessionDep,
|
|
db: DatabaseDep,
|
|
client: ClientDep,
|
|
inspect: bool = False,
|
|
page: Annotated[int, Query(ge=1)] = 1,
|
|
limit: Annotated[int, Query(ge=1, le=50)] = 30,
|
|
) -> RepositoryResponse:
|
|
response.headers["Cache-Control"] = "no-store"
|
|
pat = decrypt_pat(sess.user)
|
|
user, raw_user = await verify_identity(db, sess, client, pat)
|
|
raw, upstream = await forgejo.get(
|
|
client,
|
|
"user/repos",
|
|
pat,
|
|
"repositories",
|
|
params={"page": page, "limit": limit},
|
|
)
|
|
if not isinstance(raw, list):
|
|
raise forgejo.malformed("repositories")
|
|
try:
|
|
parsed = [ForgejoRepository.model_validate(repo) for repo in raw]
|
|
except ValidationError:
|
|
raise forgejo.malformed("repositories") from None
|
|
result = RepositoryResponse(
|
|
repositories=[
|
|
Repository(
|
|
owner=repo.owner.login,
|
|
name=repo.name,
|
|
full_name=repo.full_name,
|
|
default_branch=repo.default_branch,
|
|
private=repo.private,
|
|
)
|
|
for repo in parsed
|
|
if repo.owner.id == user.id
|
|
],
|
|
page=page,
|
|
limit=limit,
|
|
next_page=page + 1 if "next" in upstream.links else None,
|
|
)
|
|
if inspect:
|
|
result.inspection = {
|
|
"forgejo": redact(
|
|
{
|
|
"authenticated_user": raw_user,
|
|
"repositories": raw,
|
|
},
|
|
pat,
|
|
)
|
|
}
|
|
return result
|
|
|
|
|
|
def public_base_url(settings: AppSettings) -> str:
|
|
value = settings.firebreak_public_base_url.strip().rstrip("/")
|
|
try:
|
|
parsed = urlsplit(value)
|
|
valid = (
|
|
parsed.scheme in {"http", "https"}
|
|
and parsed.hostname
|
|
and not parsed.username
|
|
and not parsed.password
|
|
and not parsed.query
|
|
and not parsed.fragment
|
|
)
|
|
_ = parsed.port
|
|
except ValueError:
|
|
valid = False
|
|
if not valid:
|
|
raise HTTPException(
|
|
503,
|
|
detail={
|
|
"stage": "configuration",
|
|
"message": "Configure the Firebreak public base URL in setup.",
|
|
},
|
|
)
|
|
return value
|
|
|
|
|
|
async def require_json(request: Request) -> None:
|
|
if request.headers.get("content-type", "").split(";", 1)[0].lower() != "application/json":
|
|
raise HTTPException(415, detail={"stage": "request", "message": "Send application/json."})
|
|
|
|
|
|
@router.post(
|
|
"/", status_code=201, response_model_exclude_unset=True, dependencies=[Depends(require_json)]
|
|
)
|
|
async def create_link(
|
|
payload: CreateLinkRequest,
|
|
response: Response,
|
|
sess: SessionDep,
|
|
db: DatabaseDep,
|
|
client: ClientDep,
|
|
settings: SettingsDep,
|
|
inspect: bool = False,
|
|
) -> CreateLinkResponse:
|
|
response.headers["Cache-Control"] = "no-store"
|
|
base_url = public_base_url(settings)
|
|
pat = decrypt_pat(sess.user)
|
|
user, raw_user = await verify_identity(db, sess, client, pat)
|
|
repo_path = f"repos/{quote(payload.repo_owner, safe='')}/{quote(payload.repo_name, safe='')}"
|
|
raw_repo, _ = await forgejo.get(client, repo_path, pat, "repository")
|
|
try:
|
|
repo = ForgejoRepository.model_validate(raw_repo)
|
|
except ValidationError:
|
|
raise forgejo.malformed("repository") from None
|
|
if repo.owner.id != user.id:
|
|
raise HTTPException(
|
|
403,
|
|
detail={
|
|
"stage": "repository",
|
|
"message": "Only personally owned repositories can be shared.",
|
|
},
|
|
)
|
|
if (repo.name.casefold(), repo.owner.login.casefold()) != (
|
|
payload.repo_name.casefold(),
|
|
payload.repo_owner.casefold(),
|
|
):
|
|
raise forgejo.malformed("repository")
|
|
raw_branch, _ = await forgejo.get(
|
|
client,
|
|
f"{repo_path}/branches/{quote(payload.branch, safe='')}",
|
|
pat,
|
|
"branch",
|
|
)
|
|
commit = raw_branch.get("commit") if isinstance(raw_branch, dict) else None
|
|
sha = commit.get("id") if isinstance(commit, dict) else None
|
|
if not isinstance(sha, str) or not re.fullmatch(r"[0-9a-f]{40}|[0-9a-f]{64}", sha):
|
|
raise forgejo.malformed("branch")
|
|
if raw_branch.get("name") != payload.branch:
|
|
raise forgejo.malformed("branch")
|
|
if payload.expires_at <= datetime.now(UTC):
|
|
raise HTTPException(
|
|
422, detail={"stage": "grant", "message": "Expiration must be in the future."}
|
|
)
|
|
token = secrets.token_urlsafe(32)
|
|
grant = Grant(
|
|
user_id=sess.user_id,
|
|
repo_owner=repo.owner.login,
|
|
repo_name=repo.name,
|
|
commit_sha=sha,
|
|
grant_type="public",
|
|
expires_at=payload.expires_at,
|
|
token_hash=hashlib.sha256(token.encode()).hexdigest(),
|
|
recipient_email=None,
|
|
revoked_at=None,
|
|
)
|
|
try:
|
|
db.add(grant)
|
|
await db.flush()
|
|
await db.refresh(grant)
|
|
created = CreatedGrant(
|
|
id=grant.id,
|
|
user_id=grant.user_id,
|
|
repo_owner=grant.repo_owner,
|
|
repo_name=grant.repo_name,
|
|
commit_sha=grant.commit_sha,
|
|
grant_type="public",
|
|
created_at=grant.created_at,
|
|
expires_at=grant.expires_at,
|
|
revoked_at=grant.revoked_at,
|
|
recipient_email=None,
|
|
token_hash="[redacted]",
|
|
)
|
|
await db.commit()
|
|
except SQLAlchemyError:
|
|
await db.rollback()
|
|
raise HTTPException(
|
|
500,
|
|
detail={
|
|
"stage": "grant",
|
|
"message": "Could not save the grant. Please try again.",
|
|
},
|
|
) from None
|
|
result = CreateLinkResponse(
|
|
created_grant=created,
|
|
share_url=f"{base_url}/s/{token}",
|
|
viewer_available=False,
|
|
)
|
|
if inspect:
|
|
result.inspection = {
|
|
"request": payload.model_dump(mode="json"),
|
|
"forgejo": redact(
|
|
{
|
|
"authenticated_user": raw_user,
|
|
"repository": raw_repo,
|
|
"branch": raw_branch,
|
|
},
|
|
pat,
|
|
),
|
|
"ownership": {
|
|
"allowed": True,
|
|
"reason": "repository owner matches authenticated Forgejo user",
|
|
},
|
|
}
|
|
return result
|