Files
courrier/app/mirror_client.py
T

219 lines
8.8 KiB
Python

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