Skip to content

The agent that grows with you

3.8 KB
Raw Blame
"""Bound chat upload request bodies before FastAPI parses, spools or buffers them."""

from __future__ import annotations

from starlette.datastructures import Headers
from starlette.formparsers import MultiPartException
from starlette.responses import JSONResponse
from starlette.types import ASGIApp, Message, Receive, Scope, Send

from hermes_cli.web_server_surface import policy
from hermes_constants import WEBAPP_ATTACHMENT_MAX_BYTES

# The file cap remains exact in the handler; allow ordinary multipart headers
# and boundaries without letting arbitrary extra parts consume unbounded disk.
CHAT_FILE_BODY_MAX_BYTES = WEBAPP_ATTACHMENT_MAX_BYTES + 64 * 1024

# Largest decoded image /api/chat/image-upload stores. The image arrives base64-encoded in a JSON
# body, which FastAPI reads whole before the handler checks the image: bound the body to that
# image's base64 length plus room for the JSON around it, so an oversized paste is never buffered.
CHAT_IMAGE_MAX_BYTES = 25 * 1024 * 1024
CHAT_IMAGE_BODY_MAX_BYTES = 4 * -(-CHAT_IMAGE_MAX_BYTES // 3) + 64 * 1024

_BODY_MAX_BYTES = {
    "/api/chat/file-upload": CHAT_FILE_BODY_MAX_BYTES,
    "/api/chat/image-upload": CHAT_IMAGE_BODY_MAX_BYTES,
}


class ChatFileUploadLimitMiddleware:
    """Refuse a chat file or image upload with 413 once its body passes the route's cap: at once
    when Content-Length declares more, else at the first chunk past it. Only on the surfaces whose
    policy serves the browser's file routes (the Webapp); elsewhere uploads reach their handlers
    as on main."""

    def __init__(self, app: ASGIApp):
        self.app = app

    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
        path = scope.get("path", "")
        root = scope.get("root_path", "")
        if root and path.startswith(root + "/"):
            path = path[len(root) :]
        body_max = _BODY_MAX_BYTES.get(path)
        if (scope["type"] != "http" or scope["method"] != "POST" or body_max is None
                or not policy(getattr(scope.get("app"), "state", None)).browser_files):
            await self.app(scope, receive, send)
            return

        rejection = JSONResponse(status_code=413, content={"detail": "Upload request is too large"})
        length = Headers(scope=scope).get("content-length", "").lstrip("0") or "0"
        if (
            length.isascii()
            and length.isdecimal()
            and (len(length) > len(str(body_max)) or int(length) > body_max)
        ):
            await rejection(scope, receive, send)
            return

        received = 0
        exceeded = False

        async def limited_receive() -> Message:
            nonlocal received, exceeded
            message = await receive()
            if message["type"] == "http.request":
                received += len(message.get("body", b""))
                if received > body_max:
                    exceeded = True
                    # This exception is deliberate: Starlette's multipart parser
                    # closes *all* open spools on MultiPartException, unlike an
                    # HTTPException or cancellation. The rejected chunk never
                    # reaches the parser. Request._get_form converts it to 400,
                    # as FastAPI does for a JSON body whose read fails.
                    raise MultiPartException("Upload request is too large")
            return message

        async def limited_send(message: Message) -> None:
            if not exceeded:
                await send(message)
            elif message["type"] == "http.response.start":
                # Replace the parser's 400 (including its Content-Length) with
                # 413, after its cleanup, and suppress the original body.
                await rejection(scope, receive, send)

        await self.app(scope, limited_receive, limited_send)