Create giffer_bot.py

giffer_bot.py

@@ -0,0 +1,791 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+import io
+import os
+import re
+import time
+import random
+import logging
+import socket
+import tempfile
+import subprocess
+import json
+from logging.handlers import RotatingFileHandler
+from typing import Optional, Tuple, Dict, Any, Callable, TypeVar, List
+from concurrent.futures import ThreadPoolExecutor, TimeoutError as FuturesTimeoutError
+
+import requests
+from requests.adapters import HTTPAdapter
+
+try:
+    from urllib3.util.retry import Retry
+except Exception:
+    Retry = None  # type: ignore
+
+try:
+    import imageio_ffmpeg
+except Exception:
+    imageio_ffmpeg = None  # type: ignore
+
+
+# =======================
+# ENV loader (Windows-friendly)
+# =======================
+
+def load_env_file(path: str = "config.env") -> None:
+    if not os.path.exists(path):
+        return
+    with open(path, "r", encoding="utf-8") as f:
+        for raw in f:
+            line = raw.strip()
+            if not line or line.startswith("#") or line.startswith(";"):
+                continue
+            if "=" not in line:
+                continue
+
+            k, v = line.split("=", 1)
+            k = k.strip()
+            v = v.strip()
+
+            if v and v[0] not in "\"'":
+                m = re.search(r"\s+#", v)
+                if m:
+                    v = v[: m.start()].rstrip()
+
+            v = v.strip().strip('"').strip("'")
+            if k:
+                os.environ.setdefault(k, v)
+
+
+load_env_file()
+
+
+# =======================
+# CONFIG
+# =======================
+
+MASTODON_BASE_URL = os.getenv("MASTODON_BASE_URL", "https://bronyfurry.com").strip().rstrip("/")
+MASTODON_ACCESS_TOKEN = os.getenv("MASTODON_ACCESS_TOKEN", "").strip()
+
+FURBOORU_BASE_URL = os.getenv("FURBOORU_BASE_URL", "https://furbooru.org").strip().rstrip("/")
+FURBOORU_API_KEY = os.getenv("FURBOORU_API_KEY", "").strip()
+SAFE_FILTER_ID = os.getenv("SAFE_FILTER_ID", "").strip()
+NSFW_FILTER_ID = os.getenv("NSFW_FILTER_ID", "").strip()
+
+USER_AGENT = os.getenv("USER_AGENT", "giffer-bot/3.3 (by @giffer@bronyfurry.com)").strip()
+
+CHECK_INTERVAL = int(os.getenv("CHECK_INTERVAL", "30"))
+
+# Rate-limit / anti-spam
+USER_COOLDOWN_SEC = int(os.getenv("USER_COOLDOWN_SEC", "20"))
+GLOBAL_RATE_PER_SEC = float(os.getenv("GLOBAL_RATE_PER_SEC", "1.0"))
+GLOBAL_BURST = int(os.getenv("GLOBAL_BURST", "3"))
+
+# Network hardening
+CONNECT_TIMEOUT = float(os.getenv("CONNECT_TIMEOUT", "5"))
+READ_TIMEOUT = float(os.getenv("READ_TIMEOUT", "20"))
+SOCKET_DEFAULT_TIMEOUT = float(os.getenv("SOCKET_DEFAULT_TIMEOUT", "25"))
+
+# Watchdog for Mastodon calls
+MASTO_CALL_TIMEOUT = float(os.getenv("MASTO_CALL_TIMEOUT", "25"))
+
+# Media download safety
+MAX_GIF_BYTES = int(os.getenv("MAX_GIF_BYTES", str(25 * 1024 * 1024)))  # 25MB
+DOWNLOAD_TIMEOUT = float(os.getenv("DOWNLOAD_TIMEOUT", "40"))
+
+# Wait for Mastodon media processing
+MEDIA_PROCESS_MAX_WAIT = float(os.getenv("MEDIA_PROCESS_MAX_WAIT", "60"))
+
+NSFW_VISIBILITY = os.getenv("NSFW_VISIBILITY", "public").strip()  # public/unlisted/private/direct
+
+# Logging
+LOG_LEVEL = os.getenv("LOG_LEVEL", "INFO").upper()
+LOG_FILE = os.getenv("LOG_FILE", "giffer.log").strip() or "giffer.log"
+
+# State (for "do not reply twice")
+STATE_FILE = os.getenv("STATE_FILE", "giffer_state.json").strip() or "giffer_state.json"
+PROCESSED_CACHE_MAX = int(os.getenv("PROCESSED_CACHE_MAX", "800"))  # how many status_ids to remember
+
+
+# =======================
+# LOGGING
+# =======================
+
+logger = logging.getLogger("giffer")
+logger.setLevel(getattr(logging, LOG_LEVEL, logging.INFO))
+logger.handlers.clear()
+
+fmt = logging.Formatter("%(asctime)s [%(levelname)s] %(message)s")
+
+ch = logging.StreamHandler()
+ch.setFormatter(fmt)
+logger.addHandler(ch)
+
+fh = RotatingFileHandler(LOG_FILE, maxBytes=5 * 1024 * 1024, backupCount=3, encoding="utf-8")
+fh.setFormatter(fmt)
+logger.addHandler(fh)
+
+
+# =======================
+# GLOBAL NETWORK SETTINGS
+# =======================
+
+socket.setdefaulttimeout(SOCKET_DEFAULT_TIMEOUT)
+
+
+def make_session() -> requests.Session:
+    s = requests.Session()
+    s.headers.update({"User-Agent": USER_AGENT})
+
+    if Retry is not None:
+        retry = Retry(
+            total=3,
+            connect=3,
+            read=2,
+            status=2,
+            backoff_factor=0.6,
+            status_forcelist=(429, 500, 502, 503, 504),
+            allowed_methods=("GET", "POST"),
+            raise_on_status=False,
+        )
+        adapter = HTTPAdapter(max_retries=retry, pool_connections=10, pool_maxsize=10)
+    else:
+        adapter = HTTPAdapter(pool_connections=10, pool_maxsize=10)
+
+    s.mount("https://", adapter)
+    s.mount("http://", adapter)
+    return s
+
+
+http = make_session()
+
+_executor = ThreadPoolExecutor(max_workers=4)
+T = TypeVar("T")
+
+
+def run_with_timeout(fn: Callable[[], T], timeout: float, what: str) -> Optional[T]:
+    fut = _executor.submit(fn)
+    try:
+        return fut.result(timeout=timeout)
+    except FuturesTimeoutError:
+        logger.error("Timeout: %s (>%ss). Continuing.", what, timeout)
+        return None
+    except Exception as e:
+        logger.error("Error in %s: %s", what, e)
+        return None
+
+
+# =======================
+# STATE (persist last_seen + processed status_ids)
+# =======================
+
+def load_state() -> Dict[str, Any]:
+    if not os.path.exists(STATE_FILE):
+        return {"last_seen_notif_id": None, "processed_status_ids": []}
+    try:
+        with open(STATE_FILE, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        if "last_seen_notif_id" not in data:
+            data["last_seen_notif_id"] = None
+        if "processed_status_ids" not in data or not isinstance(data["processed_status_ids"], list):
+            data["processed_status_ids"] = []
+        return data
+    except Exception as e:
+        logger.warning("Failed to read state file (%s). Starting fresh.", e)
+        return {"last_seen_notif_id": None, "processed_status_ids": []}
+
+def save_state(state: Dict[str, Any]) -> None:
+    try:
+        tmp = STATE_FILE + ".tmp"
+        with open(tmp, "w", encoding="utf-8") as f:
+            json.dump(state, f, ensure_ascii=False)
+        os.replace(tmp, STATE_FILE)
+    except Exception as e:
+        logger.warning("Failed to write state file: %s", e)
+
+def remember_processed(state: Dict[str, Any], status_id: int) -> None:
+    arr = state.get("processed_status_ids", [])
+    arr.append(int(status_id))
+    # keep last N
+    if len(arr) > PROCESSED_CACHE_MAX:
+        arr = arr[-PROCESSED_CACHE_MAX:]
+    state["processed_status_ids"] = arr
+
+def is_processed(state: Dict[str, Any], status_id: int) -> bool:
+    try:
+        return int(status_id) in set(state.get("processed_status_ids", []))
+    except Exception:
+        return False
+
+
+# =======================
+# RATE LIMIT HELPERS
+# =======================
+
+_user_last: Dict[str, float] = {}
+_global_tokens = float(GLOBAL_BURST)
+_global_last = time.monotonic()
+
+
+def user_allowed(acct: str) -> bool:
+    now = time.time()
+    last = _user_last.get(acct, 0.0)
+    if now - last < USER_COOLDOWN_SEC:
+        logger.info("Cooldown hit for user=%s (wait %.1fs)", acct, USER_COOLDOWN_SEC - (now - last))
+        return False
+    _user_last[acct] = now
+    return True
+
+
+def global_wait_if_needed() -> None:
+    global _global_tokens, _global_last
+    now = time.monotonic()
+    elapsed = now - _global_last
+    _global_last = now
+
+    _global_tokens = min(float(GLOBAL_BURST), _global_tokens + elapsed * GLOBAL_RATE_PER_SEC)
+
+    if _global_tokens >= 1.0:
+        _global_tokens -= 1.0
+        return
+
+    need = (1.0 - _global_tokens) / max(GLOBAL_RATE_PER_SEC, 0.001)
+    logger.info("Global rate-limit wait %.2fs", need)
+    time.sleep(max(0.0, need))
+    _global_tokens = 0.0
+
+
+# =======================
+# TEXT HELPERS
+# =======================
+
+def strip_html(html: str) -> str:
+    text = re.sub(r"<[^>]+>", " ", html)
+    return re.sub(r"\s+", " ", text).strip()
+
+
+def parse_query(content_html: str) -> Tuple[str, bool]:
+    text = strip_html(content_html).lower()
+    text = re.sub(r"@\s*[a-z0-9_]+(?:@[a-z0-9\.\-]+)?", " ", text, flags=re.I)
+    text = re.sub(r"\s+", " ", text).strip()
+
+    is_nsfw = bool(re.search(r"\bnsfw\b", text))
+    text = re.sub(r"\bnsfw\b", " ", text).strip()
+    text = re.sub(r"\s+", " ", text).strip()
+    return text, is_nsfw
+
+
+def split_tags(query: str) -> List[str]:
+    q = (query or "").strip()
+    if not q:
+        return []
+    q = q.replace(",", " ")
+    parts = re.findall(r'"([^"]+)"|(\S+)', q)
+    tokens = []
+    for a, b in parts:
+        t = (a or b).strip()
+        if t:
+            tokens.append(t)
+    tokens = [t for t in tokens if t.lower() not in {"random", "rnd"}]
+    return tokens
+
+
+def safe_visibility(v: str) -> str:
+    v = (v or "public").strip().lower()
+    return v if v in {"public", "unlisted", "private", "direct"} else "public"
+
+
+def make_alt_text(img: Dict[str, Any], query: str, is_nsfw: bool) -> str:
+    tags = img.get("tags", [])
+    if isinstance(tags, list):
+        raw = [str(t).strip() for t in tags]
+    elif isinstance(tags, str):
+        raw = [t.strip() for t in tags.split(",")]
+    else:
+        raw = []
+
+    block = {"safe", "questionable", "explicit", "nsfw", "sfw", "animated", "gif"}
+    cleaned = []
+    for t in raw:
+        if not t:
+            continue
+        t2 = t.lower().strip()
+        if t2 in block:
+            continue
+        cleaned.append(t2.replace("_", " "))
+
+    seen = set()
+    uniq = []
+    for t in cleaned:
+        if t in seen:
+            continue
+        seen.add(t)
+        uniq.append(t)
+
+    prefix = "NSFW animated GIF" if is_nsfw else "Animated GIF"
+    if uniq:
+        return (f"{prefix}: " + ", ".join(uniq[:20]))[:900]
+    if query:
+        return f"{prefix} (from query): {query[:900]}"
+    return prefix
+
+
+def source_link(img: Dict[str, Any]) -> str:
+    vu = img.get("view_url")
+    if isinstance(vu, str) and vu.startswith("http"):
+        return vu
+    img_id = img.get("id")
+    if img_id is not None:
+        return f"{FURBOORU_BASE_URL}/images/{img_id}"
+    return FURBOORU_BASE_URL
+
+
+# =======================
+# FURBOORU
+# =======================
+
+def furbooru_search_gif(query: str, nsfw: bool) -> Optional[Dict[str, Any]]:
+    global_wait_if_needed()
+
+    url = f"{FURBOORU_BASE_URL}/api/v1/json/search/images"
+    base_tags = ["animated", "gif"] if nsfw else ["safe", "animated", "gif"]
+    user_tags = split_tags(query)
+    all_tags = user_tags + base_tags
+    q = ", ".join(all_tags) if all_tags else ", ".join(base_tags)
+
+    params: Dict[str, Any] = {"q": q, "per_page": 50, "page": 1}
+    if FURBOORU_API_KEY:
+        params["key"] = FURBOORU_API_KEY
+    if nsfw and NSFW_FILTER_ID:
+        params["filter_id"] = NSFW_FILTER_ID
+    if (not nsfw) and SAFE_FILTER_ID:
+        params["filter_id"] = SAFE_FILTER_ID
+
+    backoff = 1.0
+    for attempt in range(4):
+        logger.info("Furbooru search attempt=%d q=%s", attempt + 1, q)
+        try:
+            r = http.get(url, params=params, timeout=(CONNECT_TIMEOUT, READ_TIMEOUT))
+        except requests.RequestException as e:
+            logger.error("Furbooru request error: %s", e)
+            return None
+
+        if r.status_code == 429:
+            logger.warning("Furbooru 429 Too Many Requests. Backoff %.1fs", backoff)
+            time.sleep(backoff)
+            backoff *= 2
+            continue
+
+        if r.status_code >= 400:
+            logger.error("Furbooru HTTP %s: %r", r.status_code, (r.text or "")[:200])
+            return None
+
+        try:
+            data = r.json()
+        except Exception as e:
+            logger.error("Furbooru JSON parse error: %s", e)
+            return None
+
+        images = data.get("images", [])
+        candidates = []
+        for img in images:
+            if img.get("format") != "gif":
+                continue
+            if not img.get("thumbnails_generated", False):
+                continue
+            reps = img.get("representations") or {}
+            if not any(reps.get(k) for k in ("full", "large", "medium", "small", "thumb")):
+                continue
+            candidates.append(img)
+
+        logger.info("Furbooru found=%d candidates=%d", len(images), len(candidates))
+        return random.choice(candidates) if candidates else None
+
+    return None
+
+
+def representation_candidates(img: Dict[str, Any]) -> List[str]:
+    reps = img.get("representations") or {}
+    keys = ["full", "large", "medium", "small", "thumb"]
+    out: List[str] = []
+    for k in keys:
+        u = reps.get(k)
+        if isinstance(u, str) and u.startswith("http") and u not in out:
+            out.append(u)
+    return out
+
+
+def download_bytes(url: str, max_bytes: int) -> Optional[bytes]:
+    logger.info("Downloading %s", url)
+    try:
+        with http.get(url, timeout=(CONNECT_TIMEOUT, DOWNLOAD_TIMEOUT), stream=True) as r:
+            if r.status_code >= 400:
+                logger.error("Download HTTP %s", r.status_code)
+                return None
+            total = 0
+            chunks = []
+            for chunk in r.iter_content(chunk_size=64 * 1024):
+                if not chunk:
+                    continue
+                total += len(chunk)
+                if total > max_bytes:
+                    raise ValueError(f"File too large (> {max_bytes} bytes)")
+                chunks.append(chunk)
+            logger.info("Downloaded bytes=%d", total)
+            return b"".join(chunks)
+    except ValueError:
+        raise
+    except requests.RequestException as e:
+        logger.error("Download error: %s", e)
+        return None
+
+
+# =======================
+# GIF -> MP4 (ffmpeg)
+# =======================
+
+def find_ffmpeg_exe() -> Optional[str]:
+    for cmd in ("ffmpeg", "ffmpeg.exe"):
+        try:
+            p = subprocess.run([cmd, "-version"], capture_output=True, text=True)
+            if p.returncode == 0:
+                return cmd
+        except Exception:
+            pass
+    if imageio_ffmpeg is not None:
+        try:
+            return imageio_ffmpeg.get_ffmpeg_exe()
+        except Exception:
+            return None
+    return None
+
+
+def gif_bytes_to_mp4(gif_bytes: bytes) -> Optional[bytes]:
+    ffmpeg = find_ffmpeg_exe()
+    if not ffmpeg:
+        logger.error("FFmpeg not found. Install ffmpeg or `pip install imageio-ffmpeg`.")
+        return None
+
+    with tempfile.TemporaryDirectory() as td:
+        in_gif = os.path.join(td, "in.gif")
+        out_mp4 = os.path.join(td, "out.mp4")
+
+        with open(in_gif, "wb") as f:
+            f.write(gif_bytes)
+
+        cmd = [
+            ffmpeg, "-y",
+            "-i", in_gif,
+            "-vf", "scale=trunc(iw/2)*2:trunc(ih/2)*2",
+            "-movflags", "+faststart",
+            "-pix_fmt", "yuv420p",
+            "-c:v", "libx264",
+            "-preset", "veryfast",
+            "-crf", "28",
+            "-an",
+            out_mp4
+        ]
+
+        try:
+            p = subprocess.run(cmd, capture_output=True, text=True)
+        except Exception as e:
+            logger.error("FFmpeg execution error: %s", e)
+            return None
+
+        if p.returncode != 0:
+            logger.error("FFmpeg failed: %s", (p.stderr or "")[-400:])
+            return None
+
+        try:
+            with open(out_mp4, "rb") as f:
+                mp4 = f.read()
+            logger.info("Converted GIF->MP4 bytes=%d", len(mp4))
+            return mp4
+        except Exception as e:
+            logger.error("Reading MP4 failed: %s", e)
+            return None
+
+
+# =======================
+# MASTODON
+# =======================
+
+def init_mastodon():
+    if not MASTODON_ACCESS_TOKEN:
+        raise SystemExit("MASTODON_ACCESS_TOKEN is empty. Put it into config.env or env vars.")
+    from mastodon import Mastodon
+    return Mastodon(
+        access_token=MASTODON_ACCESS_TOKEN,
+        api_base_url=MASTODON_BASE_URL,
+        user_agent=USER_AGENT,
+        request_timeout=max(CONNECT_TIMEOUT + READ_TIMEOUT, 10.0),
+    )
+
+
+def upload_media(mastodon, data: bytes, mime: str, alt_text: str) -> Optional[int]:
+    bio = io.BytesIO(data)
+    bio.name = "giffer." + ("mp4" if mime == "video/mp4" else "gif")
+    logger.info("Uploading media mime=%s (alt_len=%d)", mime, len(alt_text))
+
+    def _call():
+        return mastodon.media_post(media_file=bio, mime_type=mime, description=alt_text)
+
+    media = run_with_timeout(_call, MASTO_CALL_TIMEOUT, f"mastodon.media_post({mime})")
+    if not media:
+        return None
+    return int(media["id"])
+
+
+def wait_media_ready(mastodon, media_id: int, max_wait: float) -> bool:
+    start = time.time()
+    delay = 0.6
+    while time.time() - start < max_wait:
+        att = run_with_timeout(lambda: mastodon.media(media_id), MASTO_CALL_TIMEOUT, "mastodon.media(get)")
+        if att and att.get("url"):
+            return True
+        time.sleep(delay)
+        delay = min(delay * 1.4, 3.0)
+    return False
+
+
+def post_reply_safe(mastodon, status_id: int, text: str, visibility: str) -> None:
+    def _call():
+        return mastodon.status_post(text, in_reply_to_id=status_id, visibility=visibility)
+    run_with_timeout(_call, MASTO_CALL_TIMEOUT, "mastodon.status_post(reply)")
+
+
+def post_status_with_media(mastodon, status_id: int, text: str, media_id: int,
+                          visibility: str, nsfw: bool) -> bool:
+    if nsfw:
+        def _call():
+            return mastodon.status_post(
+                text,
+                in_reply_to_id=status_id,
+                media_ids=[media_id],
+                sensitive=True,
+                spoiler_text="NSFW",
+                visibility=visibility,
+            )
+        res = run_with_timeout(_call, MASTO_CALL_TIMEOUT, "mastodon.status_post(nsfw)")
+        return res is not None
+    else:
+        def _call():
+            return mastodon.status_post(
+                text,
+                in_reply_to_id=status_id,
+                media_ids=[media_id],
+                visibility=visibility,
+            )
+        res = run_with_timeout(_call, MASTO_CALL_TIMEOUT, "mastodon.status_post(sfw)")
+        return res is not None
+
+
+def is_mastodon_422_unsupported(err_msg: str) -> bool:
+    s = (err_msg or "").lower()
+    return (" 422" in s or "unprocessable" in s) and ("not supported" in s or "gif" in s or "supported" in s)
+
+
+def upload_gif_then_mp4_fallback(mastodon, img: Dict[str, Any], alt: str) -> Tuple[Optional[int], str]:
+    urls = representation_candidates(img)
+    if not urls:
+        return None, ""
+
+    last_err = ""
+
+    # GIF attempts (big -> small)
+    for u in urls:
+        try:
+            gif_bytes = download_bytes(u, MAX_GIF_BYTES)
+            if not gif_bytes:
+                last_err = "download failed"
+                continue
+            mid = upload_media(mastodon, gif_bytes, "image/gif", alt)
+            if mid is not None:
+                return mid, "image/gif"
+            last_err = "upload timeout/none"
+        except Exception as e:
+            last_err = str(e)
+            if is_mastodon_422_unsupported(last_err):
+                logger.warning("GIF rejected (422) for %s: %s. Trying smaller...", u, last_err)
+                continue
+            logger.error("GIF upload failed hard: %s", last_err)
+            break
+
+    # MP4 fallback (use smallest downloadable gif)
+    logger.info("Trying MP4 fallback...")
+    gif_bytes = None
+    for u in reversed(urls):
+        b = download_bytes(u, MAX_GIF_BYTES)
+        if b:
+            gif_bytes = b
+            break
+    if not gif_bytes:
+        logger.error("Cannot download any GIF for MP4 conversion. Last error: %s", last_err)
+        return None, ""
+
+    mp4 = gif_bytes_to_mp4(gif_bytes)
+    if not mp4:
+        return None, ""
+
+    mid = upload_media(mastodon, mp4, "video/mp4", alt)
+    if mid is None:
+        return None, ""
+    return mid, "video/mp4"
+
+
+# =======================
+# MAIN LOOP
+# =======================
+
+def reply_text(prefix: str, query: str, src: str, used_mime: str) -> str:
+    q = query if query else "random"
+    note = "\n(конвертировано в MP4 из-за ограничений инстанса)" if used_mime == "video/mp4" else ""
+    return f"{prefix} по запросу: `{q}`{note}\nОриг: {src}"
+
+
+def main():
+    state = load_state()
+    last_seen_id = state.get("last_seen_notif_id", None)
+
+    # Convert to int if it's stored as string
+    try:
+        if last_seen_id is not None:
+            last_seen_id = int(last_seen_id)
+    except Exception:
+        last_seen_id = None
+
+    processed_set = set(int(x) for x in state.get("processed_status_ids", []) if isinstance(x, int) or str(x).isdigit())
+    # normalize back into state list
+    state["processed_status_ids"] = list(processed_set)[-PROCESSED_CACHE_MAX:]
+    save_state(state)
+
+    mastodon = init_mastodon()
+    from mastodon import MastodonError
+
+    logger.info("Starting giffer bot on %s (Furbooru: %s)", MASTODON_BASE_URL, FURBOORU_BASE_URL)
+    logger.info("Loaded state: last_seen_notif_id=%s processed_cache=%d", last_seen_id, len(state["processed_status_ids"]))
+
+    while True:
+        logger.info("Polling mentions... since_id=%s", last_seen_id)
+
+        def _fetch():
+            return mastodon.notifications(types=["mention"], since_id=last_seen_id)
+
+        notifs = run_with_timeout(_fetch, MASTO_CALL_TIMEOUT, "mastodon.notifications(mention)")
+        if notifs is None:
+            time.sleep(CHECK_INTERVAL)
+            continue
+
+        logger.info("Got %d mention notifications", len(notifs))
+
+        for notif in reversed(notifs):
+            notif_id = notif.get("id")
+            if notif_id is not None:
+                try:
+                    last_seen_id = int(notif_id)
+                    state["last_seen_notif_id"] = last_seen_id
+                    save_state(state)  # <- important: persist immediately
+                except Exception:
+                    pass
+
+            acct = notif.get("account", {}).get("acct", "unknown")
+            status = notif.get("status") or {}
+            status_id = status.get("id")
+            if not status_id:
+                continue
+
+            try:
+                status_id_int = int(status_id)
+            except Exception:
+                continue
+
+            # ---- NEW: don't reply twice ----
+            if status_id_int in processed_set:
+                logger.info("Skipping already processed status_id=%s", status_id_int)
+                continue
+
+            # mark as processed early to prevent double-processing if we crash mid-way
+            processed_set.add(status_id_int)
+            remember_processed(state, status_id_int)
+            save_state(state)
+
+            if not user_allowed(acct):
+                continue
+
+            query, is_nsfw = parse_query(status.get("content", ""))
+            logger.info("Mention from=%s nsfw=%s query=%r status_id=%s", acct, is_nsfw, query, status_id_int)
+
+            try:
+                img = furbooru_search_gif(query, is_nsfw)
+                if not img:
+                    post_reply_safe(
+                        mastodon,
+                        status_id_int,
+                        f"Ничего не нашёл по запросу: `{query or 'random'}` 😿",
+                        safe_visibility(status.get("visibility", "public")),
+                    )
+                    continue
+
+                src = source_link(img)
+                alt = make_alt_text(img, query, is_nsfw)
+
+                media_id, used_mime = upload_gif_then_mp4_fallback(mastodon, img, alt)
+                if not media_id:
+                    post_reply_safe(
+                        mastodon,
+                        status_id_int,
+                        "Не смог загрузить (инстанс отклоняет GIF/видео или проблемы сети). Попробуй другой запрос 🙏",
+                        safe_visibility(status.get("visibility", "public")),
+                    )
+                    continue
+
+                logger.info("Uploaded media_id=%s mime=%s. Waiting processing...", media_id, used_mime)
+                if not wait_media_ready(mastodon, media_id, max_wait=MEDIA_PROCESS_MAX_WAIT):
+                    post_reply_safe(
+                        mastodon,
+                        status_id_int,
+                        "Медиа загрузилось, но Mastodon слишком долго его обрабатывает. Попробуй ещё раз через минуту 🙏",
+                        safe_visibility(status.get("visibility", "public")),
+                    )
+                    continue
+
+                visibility = safe_visibility(NSFW_VISIBILITY if is_nsfw else status.get("visibility", "public"))
+                text = reply_text("NSFW" if is_nsfw else "GIF", query, src, used_mime)
+
+                posted = post_status_with_media(mastodon, status_id_int, text, media_id, visibility, nsfw=is_nsfw)
+                if posted:
+                    logger.info("Posted successfully for user=%s", acct)
+                else:
+                    logger.error("Failed to post status for user=%s (status_id=%s)", acct, status_id_int)
+
+            except ValueError as e:
+                post_reply_safe(
+                    mastodon,
+                    status_id_int,
+                    f"Не могу загрузить: {e}",
+                    safe_visibility(status.get("visibility", "public")),
+                )
+            except requests.RequestException as e:
+                post_reply_safe(
+                    mastodon,
+                    status_id_int,
+                    f"Ошибка сети: {e}",
+                    safe_visibility(status.get("visibility", "public")),
+                )
+            except MastodonError as e:
+                logger.error("Mastodon error: %s", e)
+            except Exception as e:
+                logger.exception("Unexpected error: %s", e)
+                post_reply_safe(
+                    mastodon,
+                    status_id_int,
+                    f"Неожиданная ошибка: {e}",
+                    safe_visibility(status.get("visibility", "public")),
+                )
+
+        time.sleep(CHECK_INTERVAL)
+
+
+if __name__ == "__main__":
+    main()