mirror of
https://github.com/OpenBMB/ChatDev.git
synced 2026-11-18 07:50:38 +00:00
178 lines
7.5 KiB
Python
Executable File
178 lines
7.5 KiB
Python
Executable File
"""Attachment helpers shared by HTTP routes and executors."""
|
|
|
|
import logging
|
|
import mimetypes
|
|
import os
|
|
import shutil
|
|
import tempfile
|
|
from pathlib import Path
|
|
from typing import Any, Dict, List, Optional
|
|
|
|
from fastapi import UploadFile
|
|
|
|
from entity.messages import MessageBlock, MessageBlockType
|
|
from utils.attachments import AttachmentStore, AttachmentRecord
|
|
from utils.exceptions import SecurityError, ValidationError
|
|
from utils.workspace_paths import resolve_workspace_path, session_directory_name
|
|
|
|
|
|
class AttachmentService:
|
|
"""Handles attachment lifecycle per session."""
|
|
|
|
def __init__(self, *, root: Path | str = Path("WareHouse")) -> None:
|
|
self.logger = logging.getLogger(__name__)
|
|
self.attachments_root = Path(root)
|
|
self.attachments_root.mkdir(parents=True, exist_ok=True)
|
|
env_flag = os.environ.get("MAC_AUTO_CLEAN_ATTACHMENTS", "0").strip().lower()
|
|
self.clean_on_cleanup = env_flag in {"1", "true", "yes"}
|
|
|
|
def prepare_session_workspace(self, session_id: str) -> Path:
|
|
return self._session_attachments_path(session_id, create=True)
|
|
|
|
def cleanup_session(self, session_id: str) -> None:
|
|
attachment_dir = self._session_attachments_path(session_id, create=False)
|
|
if not attachment_dir:
|
|
return
|
|
if self.clean_on_cleanup:
|
|
shutil.rmtree(attachment_dir, ignore_errors=True)
|
|
self.logger.info("Cleaned attachment directory for session %s", session_id)
|
|
else:
|
|
self.logger.info(
|
|
"Attachment cleanup disabled; preserved files for session %s", session_id
|
|
)
|
|
|
|
def get_attachment_store(self, session_id: str) -> AttachmentStore:
|
|
path = self.prepare_session_workspace(session_id)
|
|
return AttachmentStore(path)
|
|
|
|
@staticmethod
|
|
def _safe_upload_filename(raw: Optional[str]) -> str:
|
|
"""Reduce a client-supplied upload filename to a safe basename.
|
|
|
|
The multipart ``filename`` is attacker-controlled. Joining it onto the
|
|
temporary upload directory verbatim allows path traversal (e.g.
|
|
``../../../etc/cron.d/x``): the write target escapes the temp dir and the
|
|
cleanup step then unlinks the same traversed path, yielding arbitrary
|
|
file write and delete. Normalise both POSIX and Windows separators and
|
|
keep only the final path component so the write stays confined.
|
|
"""
|
|
candidate = os.path.basename((raw or "").replace("\\", "/")).strip()
|
|
if not candidate or candidate in {".", ".."}:
|
|
return "upload.bin"
|
|
return candidate
|
|
|
|
async def save_upload_file(self, session_id: str, upload: UploadFile) -> AttachmentRecord:
|
|
self._session_attachments_path(session_id, create=False)
|
|
filename = self._safe_upload_filename(upload.filename)
|
|
temp_dir = Path(tempfile.mkdtemp(prefix="mac_upload_"))
|
|
temp_path = temp_dir / filename
|
|
try:
|
|
with temp_path.open("wb") as buffer:
|
|
while True:
|
|
chunk = await upload.read(1024 * 1024)
|
|
if not chunk:
|
|
break
|
|
buffer.write(chunk)
|
|
store = self.get_attachment_store(session_id)
|
|
mime_type = upload.content_type or mimetypes.guess_type(filename)[0]
|
|
record = store.register_file(
|
|
temp_path,
|
|
kind=MessageBlockType.from_mime_type(mime_type),
|
|
display_name=filename,
|
|
mime_type=mime_type,
|
|
extra={
|
|
"source": "user_upload",
|
|
"origin": "web_upload",
|
|
"session_id": session_id,
|
|
},
|
|
)
|
|
return record
|
|
finally:
|
|
if temp_path.exists():
|
|
try:
|
|
temp_path.unlink()
|
|
except OSError:
|
|
pass
|
|
try:
|
|
temp_dir.rmdir()
|
|
except OSError:
|
|
pass
|
|
|
|
def build_attachment_blocks(
|
|
self,
|
|
session_id: str,
|
|
attachment_ids: List[str],
|
|
*,
|
|
target_store: Optional[AttachmentStore] = None,
|
|
) -> List[MessageBlock]:
|
|
if not attachment_ids:
|
|
return []
|
|
source_store = self.get_attachment_store(session_id)
|
|
source_root = source_store.root.resolve()
|
|
target_root = target_store.root.resolve() if target_store else None
|
|
blocks: List[MessageBlock] = []
|
|
for attachment_id in attachment_ids:
|
|
record = source_store.get(attachment_id)
|
|
if not record:
|
|
continue
|
|
if target_store:
|
|
copy_required = target_root != source_root
|
|
record = target_store.ingest_record(record, copy_file=copy_required)
|
|
blocks.append(record.as_message_block())
|
|
return blocks
|
|
|
|
def list_attachment_manifests(self, session_id: str) -> Dict[str, Any]:
|
|
store = self.get_attachment_store(session_id)
|
|
return store.export_manifest()
|
|
|
|
def resolve_uploaded_paths(self, session_id: str, attachments: List[str]) -> List[str]:
|
|
"""Accept only registered uploads belonging to the specified session."""
|
|
root = self._session_attachments_path(session_id, create=False)
|
|
if root is None:
|
|
raise SecurityError("Attachment upload session does not exist")
|
|
manifest = root / "attachments_manifest.json"
|
|
if manifest.is_symlink():
|
|
raise SecurityError("Attachment manifest must not be a symbolic link")
|
|
store = AttachmentStore(root)
|
|
uploaded = {}
|
|
for attachment_id in store.export_manifest():
|
|
record = store.get(attachment_id)
|
|
if (
|
|
record.extra.get("origin") == "web_upload"
|
|
and record.extra.get("session_id") == session_id
|
|
and record.ref.local_path
|
|
):
|
|
uploaded[attachment_id] = Path(record.ref.local_path)
|
|
|
|
paths = []
|
|
for value in attachments:
|
|
try:
|
|
source = uploaded.get(value)
|
|
if source is None:
|
|
requested = Path(value).expanduser().resolve()
|
|
source = next((path for path in uploaded.values() if path.resolve() == requested), None)
|
|
if source is None:
|
|
raise SecurityError("Attachment must reference a registered upload in attachment_session_id")
|
|
resolved = source.resolve()
|
|
if source.is_symlink() or not resolved.is_relative_to(root) or not resolved.is_file():
|
|
raise SecurityError("Attachment source must stay inside its upload session")
|
|
paths.append(str(resolved))
|
|
except (OSError, RuntimeError, ValueError) as exc:
|
|
raise SecurityError("Invalid uploaded attachment source") from exc
|
|
return paths
|
|
|
|
def _session_attachments_path(self, session_id: str, *, create: bool = True) -> Optional[Path]:
|
|
session_dir_name = session_directory_name(session_id)
|
|
current = self.attachments_root
|
|
for part in (session_dir_name, "code_workspace", "attachments"):
|
|
current = current / part
|
|
if current.is_symlink():
|
|
raise ValidationError("Upload session paths must not contain symbolic links", field="session_id")
|
|
path = resolve_workspace_path(
|
|
self.attachments_root, session_dir_name, "code_workspace", "attachments"
|
|
)
|
|
if create:
|
|
path.mkdir(parents=True, exist_ok=True)
|
|
return path
|
|
return path if path.exists() else None
|