Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01XGaEeS4wbkMHuVXmz5fqkh
219 lines
8.8 KiB
Python
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("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
|