import json import threading import time from collections import deque from typing import Optional, Dict, Any, List import urllib.request import urllib.error from app.config import MIRROR_URL, read_mirror_token class MirrorClient: # Le miroir renvoie au plus 100 mails par lecture : toutes les vues partagent donc une seule clé de cache. MIRROR_MAX_LATEST = 100 def __init__(self, base_url: Optional[str] = None, token: Optional[str] = None, cache_ttl_seconds: int = 60): self.base_url = (base_url or MIRROR_URL).rstrip("/") self._token = token or read_mirror_token() self.session_id: Optional[str] = None self.cache_ttl = cache_ttl_seconds self._cache: Dict[str, tuple[float, Any]] = {} self._call_times: deque = deque() self._request_counter = 0 self._lock = threading.Lock() self._refresh_started = False def _check_rate_limit(self) -> None: """Applique strictement la limite de 60 requêtes par minute.""" now = time.time() while self._call_times and now - self._call_times[0] > 60: self._call_times.popleft() if len(self._call_times) >= 60: sleep_needed = 60.0 - (now - self._call_times[0]) + 0.1 if sleep_needed > 0: time.sleep(sleep_needed) self._call_times.append(time.time()) def _get_headers(self) -> Dict[str, str]: headers = { "Authorization": f"Bearer {self._token}", "Content-Type": "application/json", "Accept": "application/json, text/event-stream" } if self.session_id: headers["mcp-session-id"] = self.session_id return headers def _initialize_session(self) -> None: """Initialise la session Streamable HTTP auprès de o365-mirror-mcp.""" self._check_rate_limit() payload = { "jsonrpc": "2.0", "id": 1, "method": "initialize", "params": { "protocolVersion": "2024-11-05", "capabilities": {}, "clientInfo": {"name": "courrier", "version": "1.0"} } } headers = { "Authorization": f"Bearer {self._token}", "Content-Type": "application/json", "Accept": "application/json, text/event-stream" } req = urllib.request.Request(self.base_url, headers=headers, data=json.dumps(payload).encode("utf-8")) try: with urllib.request.urlopen(req, timeout=15) as resp: sess_id = resp.headers.get("mcp-session-id") if not sess_id: # Certains serveurs mettent MCP-Session-Id ou mcp-session-id for k, v in resp.headers.items(): if k.lower() == "mcp-session-id": sess_id = v break self.session_id = sess_id except Exception as e: raise ConnectionError(f"Échec initialisation session MCP miroir: {e}") def call_tool(self, tool_name: str, arguments: Optional[Dict[str, Any]] = None, use_cache: bool = True, force: bool = False) -> Any: """Appel d'un outil du miroir : cache d'abord (sauf force), réseau sérialisé par un verrou (la tâche de fond et les requêtes ne partagent jamais la session en même temps).""" arguments = arguments or {} cache_key = f"{tool_name}:{json.dumps(arguments, sort_keys=True)}" if use_cache and not force and cache_key in self._cache: ts, val = self._cache[cache_key] if time.time() - ts < self.cache_ttl: return val with self._lock: return self._appel_reseau(tool_name, arguments, use_cache, cache_key, force) def _appel_reseau(self, tool_name: str, arguments: Dict[str, Any], use_cache: bool, cache_key: str, force: bool) -> Any: now = time.time() if use_cache and not force and cache_key in self._cache: ts, val = self._cache[cache_key] if now - ts < self.cache_ttl: return val if not self.session_id: self._initialize_session() self._check_rate_limit() self._request_counter += 1 req_id = self._request_counter payload = { "jsonrpc": "2.0", "id": req_id, "method": "tools/call", "params": { "name": tool_name, "arguments": arguments } } data_bytes = json.dumps(payload).encode("utf-8") req = urllib.request.Request(self.base_url, headers=self._get_headers(), data=data_bytes) try: with urllib.request.urlopen(req, timeout=20) as resp: raw_body = resp.read().decode("utf-8") except urllib.error.HTTPError as e: if e.code == 400 and not self.session_id: self._initialize_session() req = urllib.request.Request(self.base_url, headers=self._get_headers(), data=data_bytes) with urllib.request.urlopen(req, timeout=20) as resp: raw_body = resp.read().decode("utf-8") else: raise # Parsing de la réponse (peut être SSE text/event-stream ou JSON direct) result_data = None for line in raw_body.split("\n"): line = line.strip() if line.startswith("data: "): try: parsed = json.loads(line[6:]) result_data = parsed.get("result", {}) break except Exception: continue elif line.startswith("{") and line.endswith("}"): try: parsed = json.loads(line) if "result" in parsed: result_data = parsed["result"] break except Exception: continue if not result_data: result_data = {} # Les outils MCP renvoient content: [{"type": "text", "text": "..."}] content = result_data.get("content", []) final_output = None if content and isinstance(content, list) and "text" in content[0]: text_val = content[0]["text"] try: final_output = json.loads(text_val) except Exception: final_output = text_val else: final_output = result_data if use_cache: self._cache[cache_key] = (now, final_output) return final_output def get_status(self) -> Dict[str, Any]: """Consulte l'état du miroir (mirror_status).""" res = self.call_tool("mirror_status", {}, use_cache=False) return res if isinstance(res, dict) else {"raw": res} def get_latest_mails(self, folder: str = "*", n: int = 20, inclure_exclus: bool = False) -> List[Dict[str, Any]]: """Récupère les derniers emails (mirror_mail_latest).""" res = self.call_tool("mirror_mail_latest", { "folder": folder, "n": min(n, self.MIRROR_MAX_LATEST), "inclure_exclus": inclure_exclus }) if isinstance(res, dict) and "donnees" in res: return res["donnees"] return res if isinstance(res, list) else [] def get_table_mails(self, requete: str = "*", n: int = 20, inclure_exclus: bool = False) -> List[Dict[str, Any]]: """Vue tabulaire des emails (mirror_mail_table).""" res = self.call_tool("mirror_mail_table", { "requete": requete, "n": n, "inclure_exclus": inclure_exclus }) if isinstance(res, dict) and "donnees" in res: return res["donnees"] return res if isinstance(res, list) else [] def get_mails_by_tag(self, etiquette: str, periode: Optional[str] = None, n: int = 20, inclure_exclus: bool = False) -> List[Dict[str, Any]]: """Recherche par étiquette du miroir (mirror_mail_by_tag).""" args: Dict[str, Any] = {"etiquette": etiquette, "n": n, "inclure_exclus": inclure_exclus} if periode: args["periode"] = periode res = self.call_tool("mirror_mail_by_tag", args) if isinstance(res, dict) and "donnees" in res: return res["donnees"] return res if isinstance(res, list) else [] def get_mail(self, message_id: str) -> Dict[str, Any]: """Récupère le détail d'un email (mirror_mail_get).""" res = self.call_tool("mirror_mail_get", {"message_id": message_id}) return res if isinstance(res, dict) else {"raw": res} def get_mails_for_day(self, date_str: str, max_items: int = 50) -> List[Dict[str, Any]]: """ Récupère les emails correspondant à un jour donné (date_str: AAAA-MM-JJ). Utilise mirror_mail_latest avec un nombre suffisant de messages puis filtre par date. """ raw_mails = self.get_latest_mails(folder="*", n=max_items) filtered = [] for m in raw_mails: # Vérifier la présence du message_id ou id mid = m.get("message_id") or m.get("id") or m.get("hash") d_mail = m.get("date") or m.get("date_reception") or m.get("date_heure") or "" if date_str in d_mail or not date_str: m_normalized = { "message_id": mid, "date": d_mail, "expediteur": m.get("from") or m.get("expediteur") or "", "objet": m.get("sujet") or m.get("subject") or m.get("objet") or "", "etiquettes": m.get("tags") or m.get("etiquettes") or [], "apercu": m.get("snippet") or m.get("apercu") or "" } filtered.append(m_normalized) return filtered def get_mails_since(self, debut: str, max_items: int = 400) -> List[Dict[str, Any]]: """Mails dont la date est >= debut (AAAA-MM-JJ), normalisés comme get_mails_for_day.""" out = [] for m in self.get_latest_mails(folder="*", n=max_items): mid = m.get("message_id") or m.get("id") or m.get("hash") d_mail = m.get("date") or m.get("date_reception") or m.get("date_heure") or "" if d_mail[:10] >= debut: out.append({ "message_id": mid, "date": d_mail, "expediteur": m.get("from") or m.get("expediteur") or "", "objet": m.get("sujet") or m.get("subject") or m.get("objet") or "", "etiquettes": m.get("tags") or m.get("etiquettes") or [], "apercu": m.get("snippet") or m.get("apercu") or "" }) return out def rafraichir_derniers(self) -> None: """Relit les derniers mails en ignorant le cache (même clé que les vues).""" self.call_tool("mirror_mail_latest", {"folder": "*", "n": self.MIRROR_MAX_LATEST, "inclure_exclus": False}, force=True) def demarrer_rafraichissement(self, intervalle: int = 45) -> None: """Préchauffe le cache puis le rafraîchit en tâche de fond (1 lecture toutes les 45 s, loin des 60 par minute), pour que l'ouverture d'une vue n'attende jamais le miroir. Idempotent.""" if self._refresh_started: return self._refresh_started = True def boucle() -> None: while True: try: self.rafraichir_derniers() except Exception: pass # le cache expire seul et la requête suivante relira le miroir time.sleep(intervalle) threading.Thread(target=boucle, name="miroir-rafraichissement", daemon=True).start()