import json import threading from datetime import date, timedelta 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 self._fen_cache: Dict[tuple, tuple] = {} self.fenetre_ttl = 600 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} @staticmethod def _norm(m: Dict[str, Any]) -> Dict[str, Any]: return { "message_id": m.get("message_id") or m.get("id") or m.get("hash"), "date": m.get("date") or m.get("date_reception") or m.get("date_heure") or "", "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 "", "dossier": m.get("dossier") or "", "destinataires": m.get("destinataires") or "", } @staticmethod def _jour_suivant(jour: str) -> str: return (date.fromisoformat(jour) + timedelta(days=1)).isoformat() def _liste(self, res: Any) -> List[Dict[str, Any]]: if isinstance(res, dict): res = res.get("donnees") return res if isinstance(res, list) else [] def mails_fenetre(self, debut: str, fin: str) -> List[Dict[str, Any]]: """Mails reçus de debut (inclus) à fin (exclu), AAAA-MM-JJ, au-delà des 100 derniers. Recherche par fenêtres de dates (le miroir plafonne à 100 résultats) : une fenêtre pleine est coupée en deux. La recherche « e » couvre presque tout ; les mails sans objet, qu'elle manque, viennent de l'étiquette sans_objet.""" cle = (debut, fin) hit = self._fen_cache.get(cle) if hit and time.time() - hit[0] < self.fenetre_ttl: return hit[1] d0, d1 = date.fromisoformat(debut), date.fromisoformat(fin) if d1 <= d0: return [] rows = self._liste(self.call_tool("mirror_mail_search", {"q": "e", "since": debut, "until": fin, "n": self.MIRROR_MAX_LATEST, "inclure_exclus": False}, use_cache=False)) if len(rows) >= self.MIRROR_MAX_LATEST and (d1 - d0).days > 1: milieu = (d0 + timedelta(days=(d1 - d0).days // 2)).isoformat() out = self.mails_fenetre(debut, milieu) + self.mails_fenetre(milieu, fin) else: out = list(rows) out += self._liste(self.call_tool("mirror_mail_by_tag", {"etiquette": "sans_objet", "periode": f"{debut}..{(d1 - timedelta(days=1)).isoformat()}", "n": self.MIRROR_MAX_LATEST, "inclure_exclus": False}, use_cache=False)) vus, uniques = set(), [] for m in out: mid = m.get("message_id") if mid and mid not in vus: vus.add(mid) uniques.append(m) if len(self._fen_cache) > 64: self._fen_cache.clear() self._fen_cache[cle] = (time.time(), uniques) return uniques def _mails_depuis(self, debut: str, max_items: int) -> List[Dict[str, Any]]: """Derniers mails (cache partagé) complétés par des fenêtres de dates quand la lecture de 100 ne remonte pas jusqu'à debut.""" brut = self.get_latest_mails(folder="*", n=max_items) out = [self._norm(m) for m in brut if (self._norm(m)["date"][:10] >= debut)] if len(brut) >= self.MIRROR_MAX_LATEST: plus_ancien = min((self._norm(m)["date"][:10] for m in brut if self._norm(m)["date"]), default="") if plus_ancien and plus_ancien > debut: vus = {m["message_id"] for m in out} etendu = False try: for m in self.mails_fenetre(debut, self._jour_suivant(plus_ancien)): n = self._norm(m) if n["message_id"] not in vus and n["date"][:10] >= debut: vus.add(n["message_id"]) out.append(n) etendu = True if etendu: out.sort(key=lambda m: m["date"], reverse=True) except Exception: pass # le miroir reste lisible sur les 100 derniers même si la recherche échoue return out def get_sent_mails(self, n: int = 100) -> List[Dict[str, Any]]: """Derniers messages envoyés (dossier « Messages envoyés » du miroir), normalisés.""" res = self.call_tool("mirror_mail_latest", {"folder": "Messages envoyés", "n": min(n, self.MIRROR_MAX_LATEST), "inclure_exclus": False}) return [self._norm(m) for m in self._liste(res)] def get_attachment(self, message_id: str, filename: str) -> Dict[str, Any]: """Pièce jointe d'un mail (mirror_mail_attachment), jamais mise en cache (contenu volumineux).""" res = self.call_tool("mirror_mail_attachment", {"message_id": message_id, "filename": filename}, use_cache=False) 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]]: """Mails d'un jour donné (AAAA-MM-JJ).""" if not date_str: return [self._norm(m) for m in self.get_latest_mails(folder="*", n=max_items)] return [m for m in self._mails_depuis(date_str, max_items) if date_str in m["date"]] def get_mails_since(self, debut: str, max_items: int = 400) -> List[Dict[str, Any]]: """Mails dont la date est >= debut (AAAA-MM-JJ).""" return self._mails_depuis(debut, max_items)[:max_items] 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()