Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01XGaEeWkqZYNP6Wn3mGQsrL
316 lines
14 KiB
Python
316 lines
14 KiB
Python
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 "",
|
|
}
|
|
|
|
@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_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()
|