dismessage 0.4.0__py3-none-any.whl

dismessage/__init__.py

@@ -0,0 +1,877 @@
+"""DisMessage — Pixel-perfect Discord message & friend request renderer."""
+
+from __future__ import annotations
+
+import base64
+import gzip
+import html as _html
+import json
+import os
+import re
+import urllib.parse
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from typing import Any, Iterable, Optional
+
+__version__ = "0.4.0"
+__all__ = [
+    "Author", "Message", "FriendRequest", "MessageRenderer",
+    "render_html", "render_png",
+    "render_friend_request_html", "render_friend_request_png", "render_friend_request_png_lite",
+    "fetch_messages", "render_markdown", "shutdown_browser",
+    "__version__",
+]
+
+_PAYLOAD_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), "discord_payload.b64")
+
+
+def _load_payload() -> dict[str, str]:
+    with open(_PAYLOAD_PATH, "r", encoding="utf-8") as f:
+        b64 = f.read()
+    return json.loads(gzip.decompress(base64.b64decode(b64)).decode("utf-8"))
+
+
+_PAYLOAD: dict[str, str] = _load_payload()
+
+_FR_PAYLOAD: Optional[dict[str, str]] = None
+
+
+def _load_fr_payload() -> dict[str, str]:
+    global _FR_PAYLOAD
+    if _FR_PAYLOAD is not None:
+        return _FR_PAYLOAD
+    path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "friend_request_payload.b64")
+    with open(path, "r", encoding="utf-8") as f:
+        b64 = f.read()
+    _FR_PAYLOAD = json.loads(gzip.decompress(base64.b64decode(b64)).decode("utf-8"))
+    return _FR_PAYLOAD
+
+
+@dataclass
+class Author:
+    id: str
+    name: str = "Unknown"
+    display_name: Optional[str] = None
+    color: Optional[str] = None
+    avatar_url: Optional[str] = None
+    avatar_decoration_url: Optional[str] = None
+    clan_tag: Optional[str] = None
+    clan_badge_url: Optional[str] = None
+    bot: bool = False
+    verified_app: bool = False
+
+    @property
+    def effective_name(self) -> str:
+        return self.display_name or self.name
+
+
+@dataclass
+class Message:
+    author: Author
+    content: str = ""
+    timestamp: Optional[datetime] = None
+    grouped_with_previous: Optional[bool] = None
+    reply_to: Optional["Message"] = None
+    accessories_html: str = ""
+
+
+@dataclass
+class FriendRequest:
+    author: Author
+    count: int = 1
+    subtitle: str = ""
+
+
+def _esc(text: str) -> str:
+    return _html.escape(text, quote=False)
+
+
+def render_markdown(text: str) -> str:
+    if not text:
+        return ""
+
+    code_blocks: list[str] = []
+
+    def _stash_codeblock(m: re.Match[str]) -> str:
+        lang, code = m.group(1), m.group(2)
+        lang_attr = f' data-lang="{_esc(lang)}"' if lang else ""
+        idx = len(code_blocks)
+        code_blocks.append(
+            f'<pre class="codeContainer__75297"><code class="text-xs/normal_cf4812 inline"{lang_attr}>'
+            f"{_esc(code)}</code></pre>"
+        )
+        return f"\x00CODEBLOCK{idx}\x00"
+
+    text = re.sub(r"```([a-zA-Z0-9]*)\n?(.*?)```", _stash_codeblock, text, flags=re.DOTALL)
+
+    inline_codes: list[str] = []
+
+    def _stash_inline_code(m: re.Match[str]) -> str:
+        idx = len(inline_codes)
+        inline_codes.append(f'<code class="inline">{_esc(m.group(1))}</code>')
+        return f"\x00INLINECODE{idx}\x00"
+
+    text = re.sub(r"`([^`\n]+?)`", _stash_inline_code, text)
+
+    spoilers: list[str] = []
+
+    def _stash_spoiler(m: re.Match[str]) -> str:
+        idx = len(spoilers)
+        spoilers.append(f'<span class="spoilerContent__75297">{_esc(m.group(1))}</span>')
+        return f"\x00SPOILER{idx}\x00"
+
+    text = re.sub(r"\|\|(.+?)\|\|", _stash_spoiler, text, flags=re.DOTALL)
+    text = _esc(text)
+
+    text = re.sub(r"^### (.+)$", r"<h3>\1</h3>", text, flags=re.MULTILINE)
+    text = re.sub(r"^## (.+)$", r"<h2>\1</h2>", text, flags=re.MULTILINE)
+    text = re.sub(r"^# (.+)$", r"<h1>\1</h1>", text, flags=re.MULTILINE)
+    text = re.sub(r"^-# (.+)$", r'<small class="subtext__75297">\1</small>', text, flags=re.MULTILINE)
+    text = re.sub(r"^&gt; (.+)$", r'<blockquote><span>\1</span></blockquote>', text, flags=re.MULTILINE)
+
+    text = re.sub(r"\*\*(.+?)\*\*", r"<strong>\1</strong>", text, flags=re.DOTALL)
+    text = re.sub(r"__(.+?)__", r"<u>\1</u>", text, flags=re.DOTALL)
+    text = re.sub(r"~~(.+?)~~", r"<s>\1</s>", text, flags=re.DOTALL)
+    text = re.sub(r"(?<!\w)[*_](?!\s)(.+?)(?<!\s)[*_](?!\w)", r"<em>\1</em>", text, flags=re.DOTALL)
+
+    def _emoji(m: re.Match[str]) -> str:
+        animated = bool(m.group(1))
+        name = m.group(2)
+        eid = m.group(3)
+        ext = "gif" if animated else "png"
+        url = f"https://cdn.discordapp.com/emojis/{eid}.{ext}?size=32&quality=lossless"
+        return (
+            f'<span class="emojiContainer__75abc emojiContainerClickable__75abc">'
+            f'<img class="emoji" data-type="emoji" data-name=":{name}:" alt=":{name}:" '
+            f'draggable="false" src="{url}"></span>'
+        )
+    text = re.sub(r"&lt;(a)?:(\w+):(\d+)&gt;", _emoji, text)
+
+    text = re.sub(
+        r"&lt;@!?(\d+)&gt;",
+        r'<span class="mention wrapper_f61d60 interactive" role="button" tabindex="0">@user</span>',
+        text,
+    )
+    text = re.sub(
+        r"&lt;#(\d+)&gt;",
+        r'<span class="mention wrapper_f61d60 interactive" role="button" tabindex="0">#channel</span>',
+        text,
+    )
+    text = re.sub(
+        r"&lt;@&amp;(\d+)&gt;",
+        r'<span class="mention wrapper_f61d60 interactive" role="button" tabindex="0">@role</span>',
+        text,
+    )
+
+    text = re.sub(
+        r"(https?://[^\s<]+)",
+        r'<a href="\1" target="_blank" rel="noreferrer">\1</a>',
+        text,
+        flags=re.IGNORECASE,
+    )
+    text = text.replace("\n", "<br>")
+
+    text = re.sub(r"\x00CODEBLOCK(\d+)\x00", lambda m: code_blocks[int(m.group(1))], text)
+    text = re.sub(r"\x00INLINECODE(\d+)\x00", lambda m: inline_codes[int(m.group(1))], text)
+    text = re.sub(r"\x00SPOILER(\d+)\x00", lambda m: spoilers[int(m.group(1))], text)
+
+    return text
+
+
+_DISCORD_API = "https://discord.com/api/v10"
+_DISCORD_CDN = "https://cdn.discordapp.com"
+
+
+def _api_get(client: Any, path: str, *, params: Optional[dict[str, Any]] = None, token: str) -> dict[str, Any]:
+    headers = {"Authorization": token, "Accept": "application/json"}
+    if not token.startswith(("Bot ", "Bearer ")):
+        if re.match(r"^\d+\.", token):
+            headers["Authorization"] = f"Bot {token}"
+    r = client.get(f"{_DISCORD_API}{path}", headers=headers, params=params, timeout=15.0)
+    if r.status_code >= 400:
+        raise RuntimeError(f"Discord API {path} returned {r.status_code}: {r.text[:200]}")
+    return r.json()
+
+
+def _resolve_avatar_decoration(client: Any, user_id: str, *, token: str) -> Optional[str]:
+    try:
+        data = _api_get(client, f"/users/{user_id}", token=token)
+    except Exception:
+        return None
+    add = data.get("avatar_decoration_data") or {}
+    asset = add.get("asset")
+    if asset:
+        return f"{_DISCORD_CDN}/avatar-decoration-presets/{asset}.png?size=80&pas=true"
+    return None
+
+
+def _resolve_clan_tag(client: Any, user_id: str, *, token: str) -> tuple[Optional[str], Optional[str]]:
+    try:
+        data = _api_get(client, f"/users/{user_id}", token=token)
+    except Exception:
+        return None, None
+    pg = data.get("primary_guild")
+    if not pg:
+        return None, None
+    tag = pg.get("tag")
+    if not tag:
+        return None, None
+    badge_hash = pg.get("badge")
+    guild_id = pg.get("identity_guild_id") or pg.get("guild_id")
+    badge_url = None
+    if badge_hash and guild_id:
+        badge_url = f"{_DISCORD_CDN}/clan-badges/{guild_id}/{badge_hash}.png?size=16"
+    return tag, badge_url
+
+
+def fetch_messages(
+    token: str,
+    channel_id: str | int,
+    message_id: str | int,
+    *,
+    context_before: int = 0,
+    context_after: int = 0,
+    guild_id: Optional[str | int] = None,
+    resolve_clan_tag: bool = True,
+    resolve_avatar_decoration: bool = True,
+    client: Any = None,
+) -> list[Message]:
+    try:
+        import httpx
+    except ImportError as e:
+        raise RuntimeError("httpx is required for fetch_messages. Install with: pip install httpx") from e
+
+    owns_client = client is None
+    if owns_client:
+        client = httpx.Client()
+
+    try:
+        target = _api_get(client, f"/channels/{channel_id}/messages/{message_id}", token=token)
+        context: list[dict[str, Any]] = []
+        if context_before > 0:
+            before = _api_get(client, f"/channels/{channel_id}/messages", params={"limit": context_before, "before": message_id}, token=token)
+            context = list(reversed(before)) + context
+        if context_after > 0:
+            after = _api_get(client, f"/channels/{channel_id}/messages", params={"limit": context_after, "after": message_id}, token=token)
+            context = context + list(after)
+        all_raw = context + [target]
+
+        if guild_id is None:
+            try:
+                chan = _api_get(client, f"/channels/{channel_id}", token=token)
+                if chan.get("guild_id"):
+                    guild_id = chan["guild_id"]
+            except Exception:
+                pass
+
+        author_cache: dict[str, Author] = {}
+
+        def _build_author(raw_user: dict[str, Any], raw_member: Optional[dict[str, Any]] = None) -> Author:
+            uid = str(raw_user["id"])
+            if uid in author_cache:
+                return author_cache[uid]
+            name = raw_user.get("global_name") or raw_user.get("username") or "Unknown"
+            display = raw_member.get("nick") if raw_member else None
+            avatar_hash = raw_user.get("avatar")
+            if avatar_hash:
+                ext = "gif" if avatar_hash.startswith("a_") else "webp"
+                avatar_url = f"{_DISCORD_CDN}/avatars/{uid}/{avatar_hash}.{ext}?size=80"
+            else:
+                idx = (int(uid) >> 22) % 6 if uid.isdigit() else 0
+                avatar_url = f"{_DISCORD_CDN}/embed/avatars/{idx}.png"
+            decoration_url = None
+            if resolve_avatar_decoration:
+                decoration_url = _resolve_avatar_decoration(client, uid, token=token)
+            clan_tag = clan_badge = None
+            if resolve_clan_tag:
+                clan_tag, clan_badge = _resolve_clan_tag(client, uid, token=token)
+            is_bot = bool(raw_user.get("bot"))
+            verified = False
+            public_flags = raw_user.get("public_flags") or 0
+            if is_bot and (public_flags & (1 << 16)):
+                verified = True
+            author = Author(
+                id=uid, name=name, display_name=display,
+                avatar_url=avatar_url, avatar_decoration_url=decoration_url,
+                clan_tag=clan_tag, clan_badge_url=clan_badge,
+                bot=is_bot, verified_app=verified,
+            )
+            author_cache[uid] = author
+            return author
+
+        messages: list[Message] = []
+        for raw in all_raw:
+            author = _build_author(raw["author"], raw.get("member"))
+            ts = None
+            if raw.get("timestamp"):
+                try:
+                    ts = datetime.fromisoformat(raw["timestamp"].replace("Z", "+00:00"))
+                except Exception:
+                    ts = None
+            messages.append(Message(author=author, content=raw.get("content", "") or "", timestamp=ts))
+        return messages
+    finally:
+        if owns_client:
+            client.close()
+
+
+_CLAN_TAG_CHIP_RE = re.compile(
+    r'<span><span class="copyOnlyText__10651"[^>]*></span>'
+    r'<span class="chipletContainerInner__10651[^"]*clanTagChiplet_c19a55[^"]*"[^>]*>'
+    r'<span[^>]*><img[^>]*messageBadge__10651[^>]*>'
+    r'<span[^>]*>Server Tag:[^<]*</span>'
+    r'<span class="tagText__10651"[^>]*>[^<]*</span>'
+    r'</span></span></span>',
+    re.DOTALL,
+)
+
+
+def _format_timestamp(ts: Optional[datetime]) -> tuple[str, str]:
+    if ts is None:
+        return ("now", "just now")
+    try:
+        short = ts.strftime("%I:%M %p").lstrip("0")
+    except Exception:
+        short = "now"
+    full = ts.strftime("%A, %B %d, %Y at %I:%M %p").lstrip("0")
+    return (short, full)
+
+
+def _render_message_li(msg: Message, *, grouped: bool) -> str:
+    author = msg.author
+    ts_short, ts_full = _format_timestamp(msg.timestamp)
+    iso_ts = msg.timestamp.isoformat() if msg.timestamp else ""
+    rendered_content = render_markdown(msg.content)
+    username = _esc(author.effective_name)
+
+    if grouped:
+        template = _PAYLOAD["li_grouped"]
+    elif author.bot or author.verified_app:
+        template = _PAYLOAD["li_bot"]
+    elif author.avatar_decoration_url:
+        template = _PAYLOAD["li_avatar_full"]
+    else:
+        template = _PAYLOAD["li_avatar_only"]
+
+    out = (
+        template
+        .replace("__AVATAR_URL__", _esc(author.avatar_url or ""))
+        .replace("__DECORATION_URL__", _esc(author.avatar_decoration_url or ""))
+        .replace("__USERNAME__", username)
+        .replace("__DATETIME__", _esc(iso_ts))
+        .replace("__TIME_SHORT__", _esc(ts_short))
+        .replace("__TIME_FULL__", _esc(ts_full))
+        .replace("__CONTENT__", rendered_content)
+    )
+
+    if author.color:
+        color_re = re.compile(
+            r'(class="username_c19a55 clickable_c19a55" aria-expanded="false" data-text="[^"]*" role="button" tabindex="0")'
+        )
+        out = color_re.sub(rf'\1 style="color: {_esc(author.color)};"', out, count=1)
+
+    if author.clan_tag:
+        out = (
+            out
+            .replace("__CLAN_TAG__", _esc(author.clan_tag))
+            .replace("__CLAN_BADGE_URL__", _esc(author.clan_badge_url or ""))
+        )
+    else:
+        out = _CLAN_TAG_CHIP_RE.sub("", out)
+
+    if author.bot and not author.verified_app and not grouped:
+        out = re.sub(r'<svg class="botTagVerified__82f07".*?</svg>', '', out, count=1, flags=re.DOTALL)
+        out = re.sub(r'<span id="_r_ki_" class="hiddenVisually_b18fe2">Verified App</span>', '', out, count=1)
+        out = out.replace('aria-label="Verified App"', 'aria-label="Bot"', 1)
+
+    return out
+
+
+class MessageRenderer:
+    def __init__(self, group_window_seconds: int = 300) -> None:
+        self.group_window_seconds = group_window_seconds
+
+    def should_group(self, prev: Message, cur: Message) -> bool:
+        if prev.author.id != cur.author.id:
+            return False
+        if prev.content.startswith((">", "#", "-#")) or cur.content.startswith((">", "#", "-#")):
+            return False
+        if prev.timestamp is None or cur.timestamp is None:
+            return True
+        delta = abs((cur.timestamp - prev.timestamp).total_seconds())
+        return delta <= self.group_window_seconds
+
+    def render_messages(self, messages: Iterable[Message]) -> str:
+        msgs = list(messages)
+        parts: list[str] = []
+        prev: Optional[Message] = None
+        for msg in msgs:
+            grouped = False
+            if prev is not None:
+                grouped = msg.grouped_with_previous
+                if grouped is None:
+                    grouped = self.should_group(prev, msg)
+            parts.append(_render_message_li(msg, grouped=grouped))
+            prev = msg
+        messages_html = "\n".join(parts)
+        return _PAYLOAD["head"] + messages_html + _PAYLOAD["tail"]
+
+
+def render_html(
+    messages: Iterable[Message],
+    output_path: Optional[str] = None,
+    *,
+    group_window_seconds: int = 300,
+) -> str:
+    renderer = MessageRenderer(group_window_seconds=group_window_seconds)
+    html = renderer.render_messages(messages)
+    if output_path:
+        with open(output_path, "w", encoding="utf-8") as f:
+            f.write(html)
+        return output_path
+    return html
+
+
+class _PersistentBrowser:
+    _thread: Optional[Any] = None
+    _queue: Optional[Any] = None
+    _browser: Optional[Any] = None
+    _playwright: Optional[Any] = None
+    _lite: bool = False
+    _started: bool = False
+
+    @classmethod
+    def _worker(cls) -> None:
+        import queue as _queue
+        while True:
+            task = cls._queue.get()
+            if task is None:
+                break
+            fn, args, kwargs, result_queue = task
+            try:
+                result = fn(*args, **kwargs)
+                result_queue.put(("ok", result))
+            except Exception as e:
+                result_queue.put(("error", e))
+            finally:
+                if task is not None:
+                    cls._queue.task_done()
+
+    @classmethod
+    def _ensure_started(cls, lite: bool = False) -> None:
+        import queue as _queue
+        import threading
+        if cls._started and cls._lite == lite and cls._browser is not None:
+            return
+        if cls._started:
+            cls._stop()
+        cls._queue = _queue.Queue()
+        cls._thread = threading.Thread(target=cls._worker, daemon=True)
+        cls._thread.start()
+        result_q: _queue.Queue = _queue.Queue()
+        cls._queue.put((cls._start_browser, [], {"lite": lite}, result_q))
+        status, result = result_q.get()
+        if status == "error":
+            raise result
+        cls._browser = result
+        cls._lite = lite
+        cls._started = True
+        print(f"[DisMessage] Persistent Chromium started (lite={lite})")
+
+    @classmethod
+    def _start_browser(cls, lite: bool = False) -> Any:
+        from playwright.sync_api import sync_playwright
+        pw = sync_playwright().start()
+        launch_args = [
+            "--disable-blink-features=AutomationControlled",
+            "--disable-gpu", "--disable-dev-shm-usage",
+            "--disable-extensions", "--disable-background-networking",
+            "--no-first-run",
+        ]
+        if lite:
+            launch_args.extend([
+                "--no-sandbox", "--disable-sync", "--disable-translate",
+                "--disable-default-apps", "--disable-component-update",
+            ])
+        browser = pw.chromium.launch(headless=True, args=launch_args)
+        cls._playwright_obj = pw
+        return browser
+
+    @classmethod
+    def submit(cls, fn: Any, *args: Any, **kwargs: Any) -> Any:
+        import queue as _queue
+        cls._ensure_started()
+        result_q: _queue.Queue = _queue.Queue()
+        cls._queue.put((fn, args, kwargs, result_q))
+        status, result = result_q.get()
+        if status == "error":
+            raise result
+        return result
+
+    @classmethod
+    def _stop(cls) -> None:
+        if cls._queue:
+            cls._queue.put(None)
+        if cls._thread:
+            cls._thread.join(timeout=5)
+        if hasattr(cls, "_playwright_obj") and cls._playwright_obj:
+            try:
+                cls._playwright_obj.stop()
+            except Exception:
+                pass
+        cls._browser = None
+        cls._playwright = None
+        cls._playwright_obj = None
+        cls._thread = None
+        cls._queue = None
+        cls._started = False
+
+    @classmethod
+    def shutdown(cls) -> None:
+        cls._stop()
+
+
+def shutdown_browser() -> None:
+    _PersistentBrowser.shutdown()
+
+
+def _render_png_on_browser(html: str, output_path: str, width: int, lite: bool, device_scale_factor: float) -> str:
+    import tempfile, os
+    tmp_html = tempfile.mktemp(suffix=".html")
+    with open(tmp_html, "w", encoding="utf-8") as f:
+        f.write(html)
+    try:
+        browser = _PersistentBrowser._browser
+        ctx = browser.new_context(
+            viewport={"width": width, "height": 1200},
+            device_scale_factor=1.0 if lite else device_scale_factor,
+        )
+        if lite:
+            def block_resources(route):
+                if route.request.resource_type in ("font", "media"):
+                    route.abort()
+                else:
+                    route.continue_()
+            ctx.route("**/*", block_resources)
+        page = ctx.new_page()
+        page.goto(f"file://{tmp_html}", wait_until="domcontentloaded")
+        if not lite:
+            try:
+                page.wait_for_load_state("networkidle", timeout=15_000)
+            except Exception:
+                pass
+        else:
+            try:
+                page.wait_for_load_state("domcontentloaded", timeout=10_000)
+            except Exception:
+                pass
+        page.evaluate("""() => {
+            document.querySelectorAll('form, .channelBottomBarArea_f75fb0, .channelTextArea_f75fb0').forEach(el => {
+                el.style.display = 'none';
+            });
+            const header = document.querySelector('.title_f75fb0, .subtitleContainer_f75fb0, .container__9293f');
+            if (header) header.style.display = 'none';
+        }""")
+        el = (
+            page.query_selector(".scrollerInner__36d07")
+            or page.query_selector(".chatContent_f75fb0")
+            or page.query_selector("body")
+        )
+        box = el.bounding_box()
+        if box:
+            page.screenshot(path=output_path, clip={
+                "x": max(0, box["x"] - 16), "y": max(0, box["y"] - 16),
+                "width": box["width"] + 32, "height": box["height"] + 32,
+            })
+        else:
+            el.screenshot(path=output_path, omit_background=False)
+        page.close()
+        ctx.close()
+    finally:
+        try:
+            os.unlink(tmp_html)
+        except OSError:
+            pass
+    return output_path
+
+
+def render_png(
+    messages: Iterable[Message],
+    output_path: str,
+    *,
+    group_window_seconds: int = 300,
+    device_scale_factor: float = 2.0,
+    width: int = 800,
+    lite: bool = False,
+    playwright: Any = None,
+    persistent: bool = True,
+) -> str:
+    html = render_html(messages, output_path=None, group_window_seconds=group_window_seconds)
+
+    if persistent and playwright is None:
+        _PersistentBrowser.submit(_render_png_on_browser, html, output_path, width, lite, device_scale_factor)
+        return output_path
+
+    owns_pw = playwright is None
+    if owns_pw:
+        try:
+            from playwright.sync_api import sync_playwright
+        except ImportError as e:
+            raise RuntimeError("Playwright is required. Install with: pip install playwright && python -m playwright install chromium") from e
+        pw_ctx = sync_playwright().start()
+        playwright = pw_ctx
+
+    try:
+        launch_args = ["--disable-blink-features=AutomationControlled"]
+        if lite:
+            launch_args.extend(["--disable-gpu", "--disable-dev-shm-usage", "--no-sandbox", "--disable-extensions", "--disable-background-networking", "--no-first-run"])
+        browser = playwright.chromium.launch(headless=True, args=launch_args)
+        import tempfile, os
+        tmp_html = tempfile.mktemp(suffix=".html")
+        with open(tmp_html, "w", encoding="utf-8") as f:
+            f.write(html)
+        ctx = browser.new_context(viewport={"width": width, "height": 1200}, device_scale_factor=1.0 if lite else device_scale_factor)
+        page = ctx.new_page()
+        page.goto(f"file://{tmp_html}", wait_until="domcontentloaded")
+        if not lite:
+            try:
+                page.wait_for_load_state("networkidle", timeout=15_000)
+            except Exception:
+                pass
+        page.evaluate("""() => {
+            document.querySelectorAll('form, .channelBottomBarArea_f75fb0, .channelTextArea_f75fb0').forEach(el => { el.style.display = 'none'; });
+            const header = document.querySelector('.title_f75fb0, .subtitleContainer_f75fb0, .container__9293f');
+            if (header) header.style.display = 'none';
+        }""")
+        el = page.query_selector(".scrollerInner__36d07") or page.query_selector(".chatContent_f75fb0") or page.query_selector("body")
+        box = el.bounding_box()
+        if box:
+            page.screenshot(path=output_path, clip={"x": max(0, box["x"] - 16), "y": max(0, box["y"] - 16), "width": box["width"] + 32, "height": box["height"] + 32})
+        else:
+            el.screenshot(path=output_path, omit_background=False)
+        page.close()
+        ctx.close()
+        browser.close()
+        try:
+            os.unlink(tmp_html)
+        except OSError:
+            pass
+    finally:
+        if owns_pw:
+            try:
+                pw_ctx.stop()
+            except Exception:
+                pass
+    return output_path
+
+
+def render_friend_request_html(request: FriendRequest, output_path: Optional[str] = None) -> str:
+    payload = _load_fr_payload()
+    author = request.author
+    username = _esc(author.effective_name)
+    avatar_url = _esc(author.avatar_url or "")
+    if not avatar_url:
+        idx = (int(author.id) >> 22) % 6 if author.id.isdigit() else 0
+        avatar_url = f"https://cdn.discordapp.com/embed/avatars/{idx}.png"
+    subtext = _esc(request.subtitle) if request.subtitle else _esc(author.name)
+    count = str(request.count)
+
+    card = (
+        payload["card"]
+        .replace("__AVATAR_URL__", avatar_url)
+        .replace("__USERNAME__", username)
+        .replace("__SUBTEXT__", subtext)
+        .replace("__COUNT__", count)
+    )
+    html = payload["head"] + card + payload["tail"]
+
+    if output_path:
+        with open(output_path, "w", encoding="utf-8") as f:
+            f.write(html)
+        return output_path
+    return html
+
+
+def _render_fr_on_browser(html: str, output_path: str, lite: bool, device_scale_factor: float) -> str:
+    import tempfile, os
+    tmp_html = tempfile.mktemp(suffix=".html")
+    with open(tmp_html, "w", encoding="utf-8") as f:
+        f.write(html)
+    try:
+        browser = _PersistentBrowser._browser
+        ctx = browser.new_context(viewport={"width": 740, "height": 600}, device_scale_factor=1.0 if lite else device_scale_factor)
+        page = ctx.new_page()
+        page.goto(f"file://{tmp_html}", wait_until="domcontentloaded")
+        try:
+            page.wait_for_load_state("domcontentloaded", timeout=10_000)
+        except Exception:
+            pass
+        page.evaluate("""() => {
+            document.querySelectorAll('.panels__58c65, .panel_f75fb0, .container__040f0, [class*="panels"], .sidebar__1c6a5, .sidebar__74017, [class*="sidebar"], .tabBar__06f80, .children__133bf, .header__133bf').forEach(el => { el.style.display = 'none'; });
+            document.querySelectorAll('.peopleList__5ec2f').forEach(el => { el.style.overflow = 'visible'; el.style.height = 'auto'; el.style.maxHeight = 'none'; });
+        }""")
+        el = page.query_selector('.peopleList__5ec2f') or page.query_selector('.peopleListItem_cc6179') or page.query_selector('body')
+        el.screenshot(path=output_path, omit_background=False)
+        page.close()
+        ctx.close()
+    finally:
+        try:
+            os.unlink(tmp_html)
+        except OSError:
+            pass
+    return output_path
+
+
+def render_friend_request_png(
+    request: FriendRequest,
+    output_path: str,
+    *,
+    device_scale_factor: float = 2.0,
+    lite: bool = False,
+    playwright: Any = None,
+    persistent: bool = True,
+) -> str:
+    html = render_friend_request_html(request, output_path=None)
+
+    if persistent and playwright is None:
+        _PersistentBrowser.submit(_render_fr_on_browser, html, output_path, lite, device_scale_factor)
+        return output_path
+
+    owns_pw = playwright is None
+    if owns_pw:
+        try:
+            from playwright.sync_api import sync_playwright
+        except ImportError as e:
+            raise RuntimeError("Playwright is required. Install with: pip install playwright && python -m playwright install chromium") from e
+        pw_ctx = sync_playwright().start()
+        playwright = pw_ctx
+
+    try:
+        launch_args = ["--disable-blink-features=AutomationControlled"]
+        if lite:
+            launch_args.extend(["--disable-gpu", "--disable-dev-shm-usage", "--no-sandbox", "--disable-extensions", "--disable-background-networking", "--no-first-run"])
+        browser = playwright.chromium.launch(headless=True, args=launch_args)
+        import tempfile, os
+        tmp_html = tempfile.mktemp(suffix=".html")
+        with open(tmp_html, "w", encoding="utf-8") as f:
+            f.write(html)
+        ctx = browser.new_context(viewport={"width": 740, "height": 600}, device_scale_factor=1.0 if lite else device_scale_factor)
+        page = ctx.new_page()
+        page.goto(f"file://{tmp_html}", wait_until="domcontentloaded")
+        try:
+            page.wait_for_load_state("domcontentloaded", timeout=10_000)
+        except Exception:
+            pass
+        page.evaluate("""() => {
+            document.querySelectorAll('.panels__58c65, .panel_f75fb0, .container__040f0, [class*="panels"], .sidebar__1c6a5, .sidebar__74017, [class*="sidebar"], .tabBar__06f80, .children__133bf, .header__133bf').forEach(el => { el.style.display = 'none'; });
+            document.querySelectorAll('.peopleList__5ec2f').forEach(el => { el.style.overflow = 'visible'; el.style.height = 'auto'; el.style.maxHeight = 'none'; });
+        }""")
+        el = page.query_selector('.peopleList__5ec2f') or page.query_selector('.peopleListItem_cc6179') or page.query_selector('body')
+        el.screenshot(path=output_path, omit_background=False)
+        page.close()
+        ctx.close()
+        browser.close()
+        try:
+            os.unlink(tmp_html)
+        except OSError:
+            pass
+    finally:
+        if owns_pw:
+            try:
+                pw_ctx.stop()
+            except Exception:
+                pass
+    return output_path
+
+
+def render_friend_request_png_lite(request: FriendRequest, output_path: str) -> str:
+    import io
+    try:
+        from PIL import Image, ImageDraw, ImageFont
+    except ImportError as e:
+        raise RuntimeError("Pillow is required for lite mode. Install with: pip install Pillow") from e
+    try:
+        import httpx
+    except ImportError as e:
+        raise RuntimeError("httpx is required for lite mode. Install with: pip install httpx") from e
+
+    author = request.author
+    display_name = author.effective_name
+    username = author.name
+    avatar_url = author.avatar_url or ""
+
+    BG_PRIMARY = (43, 45, 49)
+    BG_ITEM = (35, 36, 40)
+    TEXT_NORMAL = (219, 222, 225)
+    TEXT_MUTED = (148, 155, 164)
+    BRAND = (88, 101, 242)
+    ACCENT = (78, 80, 88)
+    WHITE = (255, 255, 255)
+
+    scale = 2
+    W, H = 740 * scale, 62 * scale
+    img = Image.new("RGB", (W, H), BG_PRIMARY)
+    draw = ImageDraw.Draw(img)
+
+    def load_font(size, bold=False):
+        size = int(size * scale)
+        candidates = [
+            "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf" if bold else "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf",
+            "/usr/share/fonts/truetype/liberation/LiberationSans-Bold.ttf" if bold else "/usr/share/fonts/truetype/liberation/LiberationSans-Regular.ttf",
+            "/usr/share/fonts/truetype/freefont/FreeSansBold.ttf" if bold else "/usr/share/fonts/truetype/freefont/FreeSans.ttf",
+        ]
+        for path in candidates:
+            try:
+                return ImageFont.truetype(path, size)
+            except Exception:
+                continue
+        return ImageFont.load_default()
+
+    font_username = load_font(16, bold=True)
+    font_subtitle = load_font(14)
+    font_button = load_font(14, bold=True)
+
+    pad = 16 * scale
+    avatar_size = 32 * scale
+
+    avatar_img = None
+    if avatar_url:
+        try:
+            resp = httpx.get(avatar_url, timeout=10.0, follow_redirects=True)
+            if resp.status_code == 200:
+                avatar_img = Image.open(io.BytesIO(resp.content)).convert("RGBA")
+                avatar_img = avatar_img.resize((avatar_size, avatar_size), Image.LANCZOS)
+                mask = Image.new("L", (avatar_size, avatar_size), 0)
+                mask_draw = ImageDraw.Draw(mask)
+                mask_draw.ellipse([0, 0, avatar_size - 1, avatar_size - 1], fill=255)
+                img.paste(avatar_img, (pad, pad), mask)
+        except Exception:
+            pass
+
+    if avatar_img is None:
+        draw.ellipse([pad, pad, pad + avatar_size - 1, pad + avatar_size - 1], fill=(79, 82, 95))
+
+    username_x = pad + avatar_size + 12 * scale
+    draw.text((username_x, pad - 2 * scale), display_name, fill=TEXT_NORMAL, font=font_username)
+    subtitle = request.subtitle if request.subtitle else username
+    draw.text((username_x, pad + 20 * scale), subtitle, fill=TEXT_MUTED, font=font_subtitle)
+
+    btn_h = 32 * scale
+    btn_w = 72 * scale
+    btn_y = (H - btn_h) // 2
+    accept_x = W - pad - btn_w * 2 - 8 * scale
+    ignore_x = W - pad - btn_w
+
+    draw.rounded_rectangle([accept_x, btn_y, accept_x + btn_w, btn_y + btn_h], radius=4 * scale, fill=BRAND)
+    for text, x in [("Accept", accept_x), ("Ignore", ignore_x)]:
+        bbox = draw.textbbox((0, 0), text, font=font_button)
+        tw, th = bbox[2] - bbox[0], bbox[3] - bbox[1]
+        draw.text((x + (btn_w - tw) // 2, btn_y + (btn_h - th) // 2 - 2 * scale), text, fill=WHITE, font=font_button)
+
+    draw.rounded_rectangle([ignore_x, btn_y, ignore_x + btn_w, btn_y + btn_h], radius=4 * scale, fill=ACCENT)
+    bbox = draw.textbbox((0, 0), "Ignore", font=font_button)
+    tw, th = bbox[2] - bbox[0], bbox[3] - bbox[1]
+    draw.text((ignore_x + (btn_w - tw) // 2, btn_y + (btn_h - th) // 2 - 2 * scale), "Ignore", fill=WHITE, font=font_button)
+
+    img.save(output_path, "PNG")
+    return output_path