Skip to content

Drop in a screenshot and convert it to clean code (HTML/Tailwind/React/Vue)

Python
8.4 KB
Raw Blame
import base64
import hashlib
import json
import os
import tempfile
from dataclasses import dataclass
from typing import Any, cast

from fastapi import FastAPI, WebSocket
from fastapi.staticfiles import StaticFiles

from config import LOCAL_ASSET_DIR


MAX_UPLOADED_ASSET_BYTES = 20 * 1024 * 1024
TEMP_ASSET_DIR = os.path.join(tempfile.gettempdir(), "screenshot-to-code-assets")
SUPPORTED_IMAGE_TYPES = {
    "image/gif": ".gif",
    "image/jpeg": ".jpg",
    "image/png": ".png",
    "image/webp": ".webp",
}


@dataclass(frozen=True)
class TemporaryAsset:
    asset_id: str
    content_type: str


@dataclass(frozen=True)
class SavedAsset:
    asset_id: str
    public_url: str
    content_type: str


def configure_uploaded_asset_routes(app: FastAPI) -> None:
    os.makedirs(LOCAL_ASSET_DIR, exist_ok=True)
    app.mount("/local-assets", StaticFiles(directory=LOCAL_ASSET_DIR), name="local-assets")


def infer_local_asset_base_url(websocket: WebSocket) -> str:
    forwarded_host = websocket.headers.get("x-forwarded-host")
    host = (forwarded_host or websocket.headers.get("host") or "").split(",", 1)[0]
    host = host.strip()

    forwarded_proto = websocket.headers.get("x-forwarded-proto")
    raw_scheme = (forwarded_proto or websocket.url.scheme).split(",", 1)[0].strip()
    scheme = "https" if raw_scheme == "wss" else "http" if raw_scheme == "ws" else raw_scheme

    if not host:
        host = websocket.url.netloc
    if not scheme:
        scheme = "http"

    return f"{scheme}://{host}"


def _asset_url(base_url: str, route: str, filename: str) -> str:
    return f"{base_url.rstrip('/')}/{route}/{filename}"


def _digest_for_bytes(image_bytes: bytes) -> str:
    return hashlib.sha256(image_bytes).hexdigest()[:24]


def _asset_id_for_digest(digest: str) -> str:
    return f"tmp_asset_{digest}"


def _digest_for_asset_id(asset_id: str) -> str | None:
    if not asset_id.startswith("tmp_asset_"):
        return None

    digest = asset_id.removeprefix("tmp_asset_")
    if len(digest) != 24 or not all(c in "0123456789abcdef" for c in digest):
        return None

    return digest


def _content_type_for_extension(extension: str) -> str:
    return next(
        (
            candidate_type
            for candidate_type, candidate_extension in SUPPORTED_IMAGE_TYPES.items()
            if candidate_extension == extension
        ),
        "application/octet-stream",
    )


def _metadata_path(asset_id: str) -> str:
    return os.path.join(TEMP_ASSET_DIR, f"{asset_id}.json")


def _write_metadata(asset_id: str, content_type: str, asset_base_url: str) -> None:
    with open(_metadata_path(asset_id), "w") as file:
        json.dump(
            {
                "asset_id": asset_id,
                "content_type": content_type,
                "asset_base_url": asset_base_url,
            },
            file,
        )


def _read_metadata(asset_id: str) -> dict[str, str] | None:
    try:
        with open(_metadata_path(asset_id), "r") as file:
            raw_metadata: Any = json.load(file)
    except (FileNotFoundError, json.JSONDecodeError):
        return None

    if not isinstance(raw_metadata, dict):
        return None

    typed_metadata = cast(dict[str, object], raw_metadata)
    metadata: dict[str, str] = {}
    for key in ("content_type", "asset_base_url"):
        value = typed_metadata.get(key)
        if isinstance(value, str):
            metadata[key] = value
    return metadata


def _temporary_asset_path(asset_id: str) -> tuple[str, str, str, str] | None:
    if not _digest_for_asset_id(asset_id):
        return None

    metadata = _read_metadata(asset_id)
    if not metadata:
        return None

    for extension in SUPPORTED_IMAGE_TYPES.values():
        filename = f"{asset_id}{extension}"
        filepath = os.path.join(TEMP_ASSET_DIR, filename)
        if os.path.isfile(filepath):
            return (
                filepath,
                filename,
                metadata.get("content_type") or _content_type_for_extension(extension),
                metadata.get("asset_base_url") or "",
            )
    return None


def _decode_image_data_url(data_url: str) -> tuple[bytes, str, str] | None:
    """Decode a ``data:image/*`` URL into ``(bytes, content_type, extension)``.

    Returns ``None`` for non-image data URLs, unsupported image types,
    undecodable base64, or payloads over ``MAX_UPLOADED_ASSET_BYTES``.
    """
    if not data_url.startswith("data:image/") or "," not in data_url:
        return None

    header, encoded = data_url.split(",", 1)
    content_type = header.removeprefix("data:").split(";", 1)[0].lower()
    extension = SUPPORTED_IMAGE_TYPES.get(content_type)
    if not extension:
        return None

    try:
        image_bytes = base64.b64decode(encoded, validate=True)
    except ValueError:
        return None

    if len(image_bytes) > MAX_UPLOADED_ASSET_BYTES:
        return None

    return image_bytes, content_type, extension


def _finalize_asset_bytes(
    image_bytes: bytes,
    extension: str,
    content_type: str,
    asset_base_url: str,
    user_id: str | None,
) -> SavedAsset:
    """Write asset bytes to the served ``LOCAL_ASSET_DIR`` and return a SavedAsset.

    The single "finalize" step that turns bytes into a durable, served asset.
    Content-addressed by digest, so identical bytes dedupe to one file.
    ``user_id`` is unused locally but is the hook hosted backends key durable
    per-user storage off of.
    """
    _ = user_id
    digest = _digest_for_bytes(image_bytes)
    asset_id = _asset_id_for_digest(digest)
    permanent_filename = f"asset_{digest}{extension}"

    os.makedirs(LOCAL_ASSET_DIR, exist_ok=True)
    destination_path = os.path.join(LOCAL_ASSET_DIR, permanent_filename)
    if not os.path.exists(destination_path):
        with open(destination_path, "wb") as file:
            file.write(image_bytes)

    return SavedAsset(
        asset_id=asset_id,
        public_url=_asset_url(asset_base_url, "local-assets", permanent_filename),
        content_type=content_type,
    )


def persist_data_url_as_temporary_asset(
    data_url: str,
    asset_base_url: str,
) -> TemporaryAsset | None:
    """Stage an uploaded data URL as a temporary asset, pending a later promote.

    Used for user uploads, where only some images turn out to be assets the
    model keeps (via ``save_assets``); the rest stay reference-only. Callers
    that already know the image is an asset should use
    ``persist_data_url_as_asset`` instead and skip this staging hop.
    """
    decoded = _decode_image_data_url(data_url)
    if decoded is None:
        return None
    image_bytes, content_type, extension = decoded

    os.makedirs(TEMP_ASSET_DIR, exist_ok=True)
    digest = _digest_for_bytes(image_bytes)
    asset_id = _asset_id_for_digest(digest)
    filename = f"{asset_id}{extension}"
    filepath = os.path.join(TEMP_ASSET_DIR, filename)
    if not os.path.exists(filepath):
        with open(filepath, "wb") as file:
            file.write(image_bytes)
    _write_metadata(asset_id, content_type, asset_base_url)

    return TemporaryAsset(
        asset_id=asset_id,
        content_type=content_type,
    )


async def persist_data_url_as_asset(
    data_url: str,
    asset_base_url: str,
    user_id: str | None = None,
) -> SavedAsset | None:
    """Persist a data URL straight to a durable, served asset.

    Skips the temp-staging hop used for uploads: callers that already know the
    image is an asset (e.g. ``extract_assets``) commit immediately. Async to
    match ``promote_temporary_asset_id`` so hosted backends can finalize to
    remote storage without changing callers.
    """
    decoded = _decode_image_data_url(data_url)
    if decoded is None:
        return None
    image_bytes, content_type, extension = decoded
    return _finalize_asset_bytes(
        image_bytes, extension, content_type, asset_base_url, user_id
    )


async def promote_temporary_asset_id(
    asset_id: str,
    user_id: str | None = None,
) -> SavedAsset | None:
    """Finalize a previously-staged temporary asset into a served asset."""
    temporary_asset = _temporary_asset_path(asset_id)
    if not temporary_asset:
        return None

    source_path, temporary_filename, content_type, asset_base_url = temporary_asset
    _, extension = os.path.splitext(temporary_filename)
    with open(source_path, "rb") as file:
        image_bytes = file.read()
    return _finalize_asset_bytes(
        image_bytes, extension, content_type, asset_base_url, user_id
    )