import json 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: 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 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) -> Any: arguments = arguments or {} cache_key = f"{tool_name}:{json.dumps(arguments, sort_keys=True)}" now = time.time() if use_cache 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": 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_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("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