"""Local index of what we've sent (and, for WhatsApp, received) keyed by ``(chat_id, message_id)``. Telegram does NOT echo a rich message's content back in ``reply_to_message`` (``.text``/``.caption`` empty, ``.api_kwargs`` None), and WhatsApp quotes carry only the quoted message's id (Cloud API) or a thumbnail stub (Baileys) — never the original bytes. So a reply to something we sent arrives with no quotable text and no way to re-fetch a quoted attachment. We remember ``message_id -> text`` and ``message_id -> [(local_path, mime)]`` at send/receive time and look them up by ``reply_to_id`` on inbound. Best-effort and dependency-free: every operation swallows errors and degrades to a no-op / ``None`` / ``[]`` so it can never break a send or an inbound message. """ from __future__ import annotations import asyncio import json import os import threading import time from typing import Optional from utils import atomic_json_write _MAX_ENTRIES = 1000 _MAX_TEXT_CHARS = 2000 # ``atomic_json_write`` makes each WRITE atomic, not the load/merge/save triple. # ``record_async`` runs ``_update`` on worker threads, so two concurrent callers # (two inbound WhatsApp-Cloud messages, a Telegram send racing an edit) would # otherwise each load the same pre-state and the later ``os.replace`` drops the # other key. _LOCK = threading.Lock() def _store_path() -> str: from hermes_constants import get_hermes_home # honors the active profile override return os.path.join(str(get_hermes_home()), "state", "rich_sent_index.json") def _load(path: str) -> dict: try: with open(path, "r", encoding="utf-8-sig") as fh: data = json.load(fh) except (FileNotFoundError, ValueError): return {} return data if isinstance(data, dict) else {} def _update(chat_id, message_id, fields: dict) -> None: """Merge ``fields`` into the ``(chat_id, message_id)`` entry. No-op on any failure.""" path = _store_path() with _LOCK: try: os.makedirs(os.path.dirname(path), exist_ok=True) data = _load(path) key = f"{chat_id}:{message_id}" entry = data.get(key) entry = entry if isinstance(entry, dict) else {} data[key] = {**entry, **fields, "ts": int(time.time())} if len(data) > _MAX_ENTRIES: # trim oldest by timestamp for k, _ in sorted(data.items(), key=lambda kv: kv[1].get("ts", 0))[: len(data) - _MAX_ENTRIES]: data.pop(k, None) atomic_json_write(path, data, indent=None) # see _LOCK except Exception: return def record(chat_id, message_id, text: Optional[str]) -> None: """Persist ``text`` for ``(chat_id, message_id)``. No-op on any failure.""" if not text or message_id is None or chat_id is None: return _update(chat_id, message_id, {"t": text[:_MAX_TEXT_CHARS]}) def record_media(chat_id, message_id, media: list[tuple[str, str]]) -> None: """Persist local attachment ``(path, mime)`` pairs for ``(chat_id, message_id)``.""" if not media or message_id is None or chat_id is None: return _update(chat_id, message_id, {"m": [[str(p), str(mt or "")] for p, mt in media if p]}) async def record_async(chat_id, message_id, text: Optional[str]) -> None: """``record`` for coroutine callers: the read-modify-write + ``os.replace`` runs on a worker thread so the event loop is not stalled by the filesystem.""" await asyncio.to_thread(record, chat_id, message_id, text) async def record_media_async(chat_id, message_id, media: list[tuple[str, str]]) -> None: """``record_media`` for coroutine callers; see ``record_async``.""" await asyncio.to_thread(record_media, chat_id, message_id, media) def _entry(chat_id, message_id) -> dict: if message_id is None or chat_id is None: return {} entry = _load(_store_path()).get(f"{chat_id}:{message_id}") return entry if isinstance(entry, dict) else {} def lookup(chat_id, message_id) -> Optional[str]: """Return stored text for ``(chat_id, message_id)`` or ``None``.""" return _entry(chat_id, message_id).get("t") or None def lookup_media(chat_id, message_id) -> list[tuple[str, str]]: """Return stored ``(path, mime)`` pairs whose file still exists (attachments may be temp files).""" pairs = _entry(chat_id, message_id).get("m") or [] return [(p, mt) for p, mt in pairs if isinstance(p, str) and os.path.isfile(p)]