Add openai_gateway/apps.py as the single list of internal gateway apps and send X-OpenRouter-Title (plus legacy X-Title and HTTP-Referer) per app to every upstream. Label the Devii agent, bots, modifier, quiz grading, SEO metadata, community and sync callers. Shorten two app references that exceeded the 30 character limit and were recorded as default. Also includes the pending Muse Code, route health and Responses work. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
258 lines
9.8 KiB
Python
258 lines
9.8 KiB
Python
# retoor <retoor@molodetz.nl>
|
|
|
|
import base64
|
|
import logging
|
|
from pathlib import Path
|
|
from typing import Annotated
|
|
from fastapi import Depends, APIRouter, Request
|
|
from fastapi.responses import JSONResponse
|
|
from devplacepy.database import (
|
|
get_table,
|
|
get_int_setting,
|
|
get_user_attachments,
|
|
get_user_attachment,
|
|
)
|
|
from devplacepy.models import UploadUrlForm, AttachmentRenameForm, GenerateImageForm
|
|
from devplacepy.utils import require_user_api, is_admin, track_action
|
|
from devplacepy.attachments import (
|
|
store_attachment,
|
|
store_attachment_from_url,
|
|
soft_delete_attachment,
|
|
rename_attachment,
|
|
is_extension_allowed,
|
|
RemoteFetchError,
|
|
)
|
|
from devplacepy.schemas import UploadItemOut, UploadsListOut
|
|
from urllib.parse import urlparse
|
|
from devplacepy.services.audit import record as audit
|
|
from devplacepy.dependencies import json_or_form
|
|
from devplacepy import stealth
|
|
from devplacepy.config import (
|
|
INTERNAL_BASE_URL,
|
|
INTERNAL_IMAGE_MODEL,
|
|
USER_IMAGE_SIZE_DEFAULT,
|
|
USER_IMAGE_TIMEOUT_SECONDS,
|
|
)
|
|
|
|
logger = logging.getLogger(__name__)
|
|
router = APIRouter()
|
|
|
|
@router.post("/upload")
|
|
async def upload_file(request: Request):
|
|
user = require_user_api(request)
|
|
form = await request.form()
|
|
file = form.get("file")
|
|
|
|
if not file or not hasattr(file, "filename") or not file.filename:
|
|
return JSONResponse({"error": "No file provided"}, status_code=400)
|
|
|
|
ext = Path(file.filename).suffix.lower()
|
|
if not is_extension_allowed(ext):
|
|
return JSONResponse(
|
|
{"error": f"File type '{ext}' not allowed"}, status_code=415
|
|
)
|
|
|
|
try:
|
|
content = await file.read()
|
|
except Exception as e:
|
|
logger.warning(f"Failed to read uploaded file: {e}")
|
|
return JSONResponse({"error": "Failed to read file"}, status_code=400)
|
|
|
|
result = store_attachment(content, file.filename, user["uid"])
|
|
if result is None:
|
|
max_size_mb = get_int_setting("max_upload_size_mb", 10)
|
|
return JSONResponse(
|
|
{"error": f"File exceeds {max_size_mb}MB limit"}, status_code=413
|
|
)
|
|
|
|
logger.info(
|
|
f"File uploaded: {file.filename} ({len(content)} bytes) -> {result['url']}"
|
|
)
|
|
audit.record(
|
|
request,
|
|
"attachment.upload",
|
|
user=user,
|
|
target_type="attachment",
|
|
target_uid=result.get("uid"),
|
|
target_label=file.filename,
|
|
metadata={"size": len(content), "mime": result.get("mime_type")},
|
|
summary=f"{user['username']} uploaded attachment {file.filename}",
|
|
links=[audit.attachment_link(result.get("uid"), file.filename)],
|
|
)
|
|
track_action(user["uid"], "upload")
|
|
return JSONResponse(result, status_code=201)
|
|
|
|
@router.post("/upload-url")
|
|
async def upload_from_url(request: Request, data: Annotated[UploadUrlForm, Depends(json_or_form(UploadUrlForm))]):
|
|
user = require_user_api(request)
|
|
try:
|
|
result = await store_attachment_from_url(data.url, user["uid"], data.filename)
|
|
except RemoteFetchError as exc:
|
|
return JSONResponse({"error": exc.message}, status_code=exc.status)
|
|
|
|
logger.info(
|
|
f"URL attached: {data.url} ({result['file_size']} bytes) -> {result['url']}"
|
|
)
|
|
audit.record(
|
|
request,
|
|
"attachment.upload_url",
|
|
user=user,
|
|
target_type="attachment",
|
|
target_uid=result.get("uid"),
|
|
target_label=result.get("filename"),
|
|
metadata={"source_host": urlparse(data.url).hostname, "size": result.get("file_size"), "mime": result.get("mime_type")},
|
|
summary=f"{user['username']} attached a remote file from {urlparse(data.url).hostname}",
|
|
links=[audit.attachment_link(result.get("uid"), result.get("filename"))],
|
|
)
|
|
return JSONResponse(result, status_code=201)
|
|
|
|
@router.post("/generate-image")
|
|
async def generate_image(request: Request, data: Annotated[GenerateImageForm, Depends(json_or_form(GenerateImageForm))]):
|
|
user = require_user_api(request)
|
|
body = {
|
|
"model": INTERNAL_IMAGE_MODEL,
|
|
"prompt": data.prompt,
|
|
"size": data.size or USER_IMAGE_SIZE_DEFAULT,
|
|
"response_format": "b64_json",
|
|
"n": 1,
|
|
}
|
|
headers = {
|
|
"Content-Type": "application/json",
|
|
"X-App-Reference": "devplace-image-gen-v-1-0-0",
|
|
"Authorization": f"Bearer {user.get('api_key', '')}",
|
|
}
|
|
try:
|
|
async with stealth.stealth_async_client(timeout=USER_IMAGE_TIMEOUT_SECONDS) as client:
|
|
response = await client.post(
|
|
f"{INTERNAL_BASE_URL}/openai/v1/images/generations", json=body, headers=headers
|
|
)
|
|
payload = response.json() if response.content else {}
|
|
if response.status_code >= 400:
|
|
detail = (payload.get("error") or {}).get("message") if isinstance(payload, dict) else None
|
|
return JSONResponse(
|
|
{"error": detail or f"Image generation failed ({response.status_code})"},
|
|
status_code=502,
|
|
)
|
|
items = payload.get("data") or []
|
|
item = items[0] if items else {}
|
|
encoded = item.get("b64_json") or ""
|
|
if encoded:
|
|
content = base64.b64decode(encoded)
|
|
elif item.get("url"):
|
|
download = await client.get(item["url"])
|
|
download.raise_for_status()
|
|
content = download.content
|
|
else:
|
|
return JSONResponse({"error": "Image provider returned no image"}, status_code=502)
|
|
except Exception as exc:
|
|
logger.warning(f"Image generation failed: {exc}")
|
|
return JSONResponse({"error": f"Image generation failed: {exc}"}, status_code=502)
|
|
|
|
result = store_attachment(content, "generated.png", user["uid"])
|
|
if result is None:
|
|
return JSONResponse({"error": "Generated image exceeds the upload limit"}, status_code=413)
|
|
audit.record(
|
|
request,
|
|
"attachment.generate_image",
|
|
user=user,
|
|
target_type="attachment",
|
|
target_uid=result.get("uid"),
|
|
target_label="generated.png",
|
|
metadata={"size": len(content), "prompt": data.prompt[:200]},
|
|
summary=f"{user['username']} generated an image",
|
|
links=[audit.attachment_link(result.get("uid"), "generated.png")],
|
|
)
|
|
track_action(user["uid"], "upload")
|
|
return JSONResponse(result, status_code=201)
|
|
|
|
|
|
def _linked_filter(linked):
|
|
if linked is None:
|
|
return None
|
|
return linked.strip().lower() in ("1", "true", "yes", "linked")
|
|
|
|
|
|
@router.get("")
|
|
async def list_attachments(
|
|
request: Request, page: int = 1, linked: str | None = None
|
|
):
|
|
user = require_user_api(request)
|
|
items, pagination = get_user_attachments(
|
|
user["uid"], page=page, linked=_linked_filter(linked)
|
|
)
|
|
payload = {
|
|
"attachments": items,
|
|
"pagination": pagination,
|
|
"total": pagination.get("total", len(items)),
|
|
}
|
|
return JSONResponse(UploadsListOut.model_validate(payload).model_dump(mode="json"))
|
|
|
|
|
|
@router.get("/{attachment_uid}")
|
|
async def get_attachment_route(request: Request, attachment_uid: str):
|
|
user = require_user_api(request)
|
|
item = get_user_attachment(attachment_uid)
|
|
if not item:
|
|
return JSONResponse({"error": "Attachment not found"}, status_code=404)
|
|
if item.get("user_uid") and item["user_uid"] != user["uid"] and not is_admin(user):
|
|
return JSONResponse({"error": "Not authorized"}, status_code=403)
|
|
return JSONResponse(UploadItemOut.model_validate(item).model_dump(mode="json"))
|
|
|
|
|
|
@router.patch("/{attachment_uid}")
|
|
async def rename_attachment_route(
|
|
request: Request,
|
|
attachment_uid: str,
|
|
data: Annotated[
|
|
AttachmentRenameForm, Depends(json_or_form(AttachmentRenameForm))
|
|
],
|
|
):
|
|
user = require_user_api(request)
|
|
att = get_table("attachments").find_one(uid=attachment_uid, deleted_at=None)
|
|
if not att:
|
|
return JSONResponse({"error": "Attachment not found"}, status_code=404)
|
|
if att.get("user_uid") and att["user_uid"] != user["uid"] and not is_admin(user):
|
|
return JSONResponse({"error": "Not authorized"}, status_code=403)
|
|
old_name = att.get("original_filename")
|
|
new_name = rename_attachment(attachment_uid, data.filename)
|
|
if new_name is None:
|
|
return JSONResponse({"error": "Invalid filename"}, status_code=400)
|
|
logger.info(f"Attachment {attachment_uid} renamed to {new_name} by {user['username']}")
|
|
audit.record(
|
|
request,
|
|
"attachment.rename",
|
|
user=user,
|
|
target_type="attachment",
|
|
target_uid=attachment_uid,
|
|
target_label=new_name,
|
|
old_value=old_name,
|
|
new_value=new_name,
|
|
summary=f"{user['username']} renamed attachment to {new_name}",
|
|
links=[audit.attachment_link(attachment_uid, new_name)],
|
|
)
|
|
item = get_user_attachment(attachment_uid)
|
|
return JSONResponse(UploadItemOut.model_validate(item).model_dump(mode="json"))
|
|
|
|
|
|
@router.delete("/delete/{attachment_uid}")
|
|
async def delete_attachment_route(request: Request, attachment_uid: str):
|
|
user = require_user_api(request)
|
|
att = get_table("attachments").find_one(uid=attachment_uid, deleted_at=None)
|
|
if not att:
|
|
return JSONResponse({"error": "Attachment not found"}, status_code=404)
|
|
if att.get("user_uid") and att["user_uid"] != user["uid"] and not is_admin(user):
|
|
return JSONResponse({"error": "Not authorized"}, status_code=403)
|
|
soft_delete_attachment(attachment_uid, deleted_by=user["uid"])
|
|
logger.info(f"Attachment {attachment_uid} soft-deleted by {user['username']}")
|
|
audit.record(
|
|
request,
|
|
"attachment.delete",
|
|
user=user,
|
|
target_type="attachment",
|
|
target_uid=attachment_uid,
|
|
target_label=att.get("filename"),
|
|
summary=f"{user['username']} deleted attachment {att.get('filename') or attachment_uid}",
|
|
links=[audit.attachment_link(attachment_uid, att.get("filename"))],
|
|
)
|
|
return JSONResponse({"status": "deleted"})
|