feat: chat — suppression de post, messages privés, boîte compacte, link preview #191

backend/file_chat.py

@@ -15,14 +15,18 @@ uploaded under ``data/chat_uploads/``.
 from __future__ import annotations
 
 import hashlib
+import html
 import json
 import logging
+import re
 import shutil
 import time
 import uuid
 from pathlib import Path
 from typing import Any
 
+import httpx
+
 logger = logging.getLogger("obsigate.file_chat")
 
 CHAT_DIR = Path("data/chats")
@@ -33,6 +37,11 @@ MAX_TEXT = 4000  # characters per message
 GLOBAL_VAULT = "__global__"
 GLOBAL_PATH = "general"
 
+# #191 — private (2 users) conversations reuse the same store: the vault is
+# the reserved sentinel and the path is the sorted username pair, so the
+# storage key never depends on who asks.
+DM_VAULT = "__dm__"
+
 # #190 — attachments (image/video) live outside the vaults.
 UPLOAD_DIR = Path("data/chat_uploads")
 MAX_UPLOAD_BYTES = 25 * 1024 * 1024  # 25 MB per attachment
@@ -41,6 +50,10 @@ ALLOWED_ATTACH_EXT = {
     ".mp4", ".webm", ".ogg", ".mov", ".m4v",
 }
 
+# #191 — link preview fetch budget
+PREVIEW_TIMEOUT = 5.0  # seconds
+PREVIEW_MAX_BYTES = 512 * 1024  # only the head of the page is parsed
+
 
 def _chat_file(vault: str, path: str) -> Path:
     """Return the chat file for *(vault, path)* (hashed, traversal-proof)."""
@@ -85,11 +98,13 @@ def add_message(
     user: str,
     text: str,
     attachment: dict[str, Any] | None = None,
+    preview: dict[str, Any] | None = None,
 ) -> dict[str, Any]:
     """Append a message and persist it. Returns the stored message.
 
     The list is capped at :data:`MAX_MESSAGES` (oldest dropped first).
-    *attachment* (#190) is ``{name, url, mime, kind}`` for image/video/url.
+    *attachment* (#190) is ``{name, url, mime, kind}`` for image/video/url;
+    *preview* (#191) is the OpenGraph card of the first URL in *text*.
     """
     text = (text or "").strip()[:MAX_TEXT]
     msg: dict[str, Any] = {
@@ -100,6 +115,8 @@ def add_message(
     }
     if attachment:
         msg["attachment"] = attachment
+    if preview:
+        msg["preview"] = preview
     doc = _read(vault, path)
     return _append(vault, path, doc, msg)
 
@@ -120,6 +137,47 @@ def _append(
     return msg
 
 
+# --- #191 : messages privés (2 utilisateurs) -------------------------------
+
+def dm_path(user_a: str, user_b: str) -> str:
+    """Storage path for the private conversation between two users.
+
+    The pair is sorted so both participants address the same document.
+    """
+    return "|".join(sorted([user_a, user_b]))
+
+
+def get_dm_messages(user_a: str, user_b: str) -> list[dict[str, Any]]:
+    """Return the private history between two users (chronological)."""
+    return get_messages(DM_VAULT, dm_path(user_a, user_b))
+
+
+def add_dm_message(
+    user_a: str,
+    user_b: str,
+    author: str,
+    text: str,
+    attachment: dict[str, Any] | None = None,
+    preview: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    """Append a private message. Returns the stored message."""
+    return add_message(DM_VAULT, dm_path(user_a, user_b), author, text, attachment, preview)
+
+
+# --- #191 : suppression -----------------------------------------------------
+
+def delete_message(vault: str, path: str, message_id: str) -> bool:
+    """Remove one message from a conversation. True when it existed."""
+    doc = _read(vault, path)
+    messages = list(doc.get("messages", []))
+    kept = [m for m in messages if m.get("id") != message_id]
+    if len(kept) == len(messages):
+        return False
+    doc["messages"] = kept
+    _write(_chat_file(vault, path), doc)
+    return True
+
+
 # --- #190 : chat général (conversation centrale, hors fichier) -------------
 
 def get_global_messages() -> list[dict[str, Any]]:
@@ -131,9 +189,10 @@ def add_global_message(
     user: str,
     text: str,
     attachment: dict[str, Any] | None = None,
+    preview: dict[str, Any] | None = None,
 ) -> dict[str, Any]:
     """Append a message to the general chat. Returns the stored message."""
-    return add_message(GLOBAL_VAULT, GLOBAL_PATH, user, text, attachment)
+    return add_message(GLOBAL_VAULT, GLOBAL_PATH, user, text, attachment, preview)
 
 
 def save_attachment(filename: str, data: bytes) -> dict[str, Any]:
@@ -166,6 +225,75 @@ def save_attachment(filename: str, data: bytes) -> dict[str, Any]:
     }
 
 
+# --- #191 : link preview ----------------------------------------------------
+
+_URL_RE = re.compile(r"https?://[^\s<>\"']+")
+_PREVIEW_CACHE: dict[str, dict[str, Any] | None] = {}
+PREVIEW_CACHE_MAX = 200
+
+
+def _og(content: str, prop: str) -> str:
+    """Extract one OpenGraph/``<title>`` value from an HTML head (regex)."""
+    for pattern in (
+        rf'<meta[^>]+(?:property|name)="{prop}"[^>]+content="([^"]*)"',
+        rf'<meta[^>]+content="([^"]*)"[^>]+(?:property|name)="{prop}"',
+    ):
+        m = re.search(pattern, content, re.IGNORECASE)
+        if m:
+            return html.unescape(m.group(1)).strip()[:300]
+    if prop == "og:title":
+        m = re.search(r"<title[^>]*>([^<]*)</title>", content, re.IGNORECASE)
+        if m:
+            return html.unescape(m.group(1)).strip()[:300]
+    return ""
+
+
+def build_preview(text: str) -> dict[str, Any] | None:
+    """Fetch OpenGraph metadata for the first URL in *text* (#191).
+
+    SSRF-guarded (reuses the web-tool guard), size/time capped, cached in a
+    bounded dict. Returns ``{url, title, description, image, site}`` or
+    ``None`` when there is no URL / the fetch fails (never raises: a dead
+    link must not block the message).
+    """
+    m = _URL_RE.search(text or "")
+    if not m:
+        return None
+    url = m.group(0).rstrip(".,;:!?)")
+    if url in _PREVIEW_CACHE:
+        cached = _PREVIEW_CACHE[url]
+        return dict(cached) if cached else None
+    try:
+        from backend.tools.web import USER_AGENT, _assert_public_http_url
+
+        _assert_public_http_url(url)
+        resp = httpx.get(
+            url,
+            headers={"User-Agent": USER_AGENT, "Accept": "text/html,*/*"},
+            timeout=PREVIEW_TIMEOUT,
+            follow_redirects=True,
+        )
+        if resp.status_code >= 400:
+            raise ValueError(f"HTTP {resp.status_code}")
+        body = resp.text[:PREVIEW_MAX_BYTES]
+        preview = {
+            "url": url,
+            "title": _og(body, "og:title") or _og(body, "og:site_name"),
+            "description": _og(body, "og:description"),
+            "image": _og(body, "og:image"),
+            "site": _og(body, "og:site_name") or (url.split("/")[2] if "/" in url[8:] else url),
+        }
+        if not preview["title"]:
+            raise ValueError("pas de titre")
+    except Exception as e:
+        logger.debug("link preview failed for %s: %s", url, e)
+        preview = None
+    if len(_PREVIEW_CACHE) >= PREVIEW_CACHE_MAX:
+        _PREVIEW_CACHE.pop(next(iter(_PREVIEW_CACHE)))  # oldest first (dict order)
+    _PREVIEW_CACHE[url] = preview
+    return dict(preview) if preview else None
+
+
 def attachment_path(name: str) -> Path | None:
     """Resolve an attachment by its stored name (UUID+ext only, no traversal)."""
     p = Path(name)