"""La web app : API/.venv/bin/python app/serveur/serveur.py → http://127.0.0.1:8770 Le serveur FastAPI sert la page React construite (app/web/dist, `npm run build` dans app/web) et l'API sous /api. La page Support pilote les agents de API/ (API/support/seance.py). Une séance à la fois, en mémoire ; /api/flux pousse à la page les événements des agents (server-sent events). La page Data lit data/ et les étiquettes de labeling/ (station.py). Réglages : AIMSIGHT_DATA (données), AIMSIGHT_LABELS (étiquettes), AIMSIGHT_CASES (séances), AIMSIGHT_PORT (port, 8770). """ import asyncio import base64 import json import os import platform import subprocess import sys import threading import webbrowser from pathlib import Path import uvicorn from fastapi import FastAPI, Query, Request from fastapi.responses import FileResponse, JSONResponse, StreamingResponse import libredesk import station from fastapi.staticfiles import StaticFiles APP = Path(__file__).resolve().parents[1] sys.path.insert(0, str(APP.parent / "API" / "support")) # les agents du support from seance import Seance, donnees_par_defaut # noqa: E402 PORT = int(os.environ.get("AIMSIGHT_PORT", 8770)) HOTES = {"127.0.0.1", "localhost"} # contre le DNS rebinding : un autre site ne lit ni mails ni PDF PAGE = APP / "web" / "dist" CLIENT = None # le client Anthropic des séances ; None : le vrai (check.py y met un faux) verrou = threading.Lock() etat = {"seance": None, "evenements": []} app = FastAPI(docs_url=None, redoc_url=None, openapi_url=None) def journal(e: dict) -> None: with verrou: etat["evenements"].append(e) def en_fond(f, *args): def lancer(): try: f(*args) except Exception as e: # noqa: BLE001 — une erreur de la séance s'affiche dans la page, le serveur continue journal({"agent": "support", "type": "erreur", "texte": f"{type(e).__name__}: {e}"}) threading.Thread(target=lancer, daemon=True).start() def erreur(code: int, texte: str) -> JSONResponse: return JSONResponse({"erreur": texte}, code) @app.middleware("http") async def garde(request: Request, suite): """Seule la page elle-même parle au serveur : bon Host ; en POST, un JSON déclaré (une page d'un autre site ne peut l'envoyer sans requête préalable, à laquelle le serveur ne répond pas).""" hote = request.headers.get("host", "").rsplit(":", 1)[0] if hote not in HOTES or (request.method in ("POST", "PUT", "DELETE") and not request.headers.get("content-type", "").startswith("application/json")): return erreur(403, "requête refusée") return await suite(request) def instantane(depuis: int) -> dict: s = etat["seance"] with verrou: evs, n = etat["evenements"][depuis:], len(etat["evenements"]) v = s.derniere_version() if s else None return {"evenements": evs, "n": n, "cout": s.cout() if s else None, "version": v.name if v else None, "dossier": s.dossier.name if s else None, "id": s.id if s else None, "station": s.station if s else None, "sortie": s.sortie if s else None, "occupe": {a: bool(s and s.occupe(a)) for a in ("support", "analyste")}} @app.get("/api/flux") async def flux(request: Request): """Un message à chaque changement : les nouveaux événements et l'état de la séance. Une nouvelle séance repart de zéro (son id change) : la page vide alors ses fils.""" async def messages(): n, id_vu, dernier, calme = 0, None, None, 0 while not await request.is_disconnected(): s = etat["seance"] if s and s.id != id_vu: n, id_vu = 0, s.id m = instantane(n) reste = {k: v for k, v in m.items() if k != "evenements"} if m["evenements"] or reste != dernier or dernier is None: m["depuis"] = n # 0 : tout l'historique de la séance, la page remplace ses fils au lieu d'ajouter n, dernier, calme = m["n"], reste, 0 yield f"data: {json.dumps(m, ensure_ascii=False)}\n\n" elif (calme := calme + 1) >= 60: # ~15 s sans rien : un commentaire garde la connexion ouverte calme = 0 yield ": calme\n\n" await asyncio.sleep(0.25) return StreamingResponse(messages(), media_type="text/event-stream", headers={"Cache-Control": "no-cache"}) @app.get("/api/pdf") def pdf(): s = etat["seance"] v = s.derniere_version() if s else None if not v or v.suffix != ".pdf": return erreur(404, "pas encore de PDF") return FileResponse(v, media_type="application/pdf", filename=f"{s.dossier.name}_{v.name}", content_disposition_type="inline") @app.get("/api/mail") def mail(): s = etat["seance"] v = s.derniere_version() if s else None if not v or v.suffix != ".json": return erreur(404, "pas encore de mail") return json.loads(v.read_text()) @app.get("/api/piece/{nom}") def piece(nom: str, telecharger: bool = False): """Une pièce jointe du mail : seulement un fichier que cite la dernière version.""" s = etat["seance"] v = s.derniere_version() if s else None if not v or v.suffix != ".json" or nom not in json.loads(v.read_text())["pieces_jointes"]: return erreur(404, "pièce inconnue") return FileResponse(s.dossier / nom, filename=nom, content_disposition_type="attachment" if telecharger else "inline") @app.post("/api/analyser") def analyser(corps: dict): s = etat["seance"] if s and (s.occupe("support") or s.occupe("analyste")): return erreur(409, "une séance travaille encore") if not corps.get("mail", "").strip(): return erreur(400, "le mail est vide") if corps.get("sortie", "pdf") not in ("pdf", "mail"): return erreur(400, "sortie : pdf ou mail") images = [(i["type"], base64.b64decode(i["base64"])) for i in corps.get("images", [])] s = Seance(corps["mail"], images, corps.get("contexte", ""), donnees_par_defaut(), journal, client=CLIENT, sortie=corps.get("sortie", "pdf")) with verrou: etat["seance"], etat["evenements"] = s, [] en_fond(s.demarrer) return {"dossier": s.dossier.name} @app.post("/api/message") def message(corps: dict): s, agent, texte = etat["seance"], corps.get("agent"), corps.get("texte", "").strip() if not s: return erreur(400, "pas de séance : coller un mail et Analyser") if agent not in ("support", "analyste") or not texte: return erreur(400, "agent ou texte manquant") if s.occupe(agent): return erreur(409, f"{agent} occupé") en_fond(s.parler, agent, texte) return {} # --- les mails de LibreDesk (libredesk.py), pour remplir la page Support @app.get("/api/libredesk") def libredesk_liste(): try: return libredesk.conversations() except Exception as e: # noqa: BLE001 — non configuré ou injoignable : le dire dans la page return erreur(502, f"LibreDesk : {e}") @app.get("/api/libredesk/{uuid}") def libredesk_conversation(uuid: str): try: return libredesk.conversation(uuid) except Exception as e: # noqa: BLE001 return erreur(502, f"LibreDesk : {e}") # --- la page Data (station.py) @app.exception_handler(station.Refus) def refus(_, e): return erreur(400, str(e)) @app.get("/api/stations") def stations(): return station.stations() @app.get("/api/images") def images(station_: str = Query(alias="station"), du: str = "", au: str = ""): return station.images(station_, du, au) @app.get("/api/image/{station_}/{nom}") def image(station_: str, nom: str): return FileResponse(station.image(station_, nom), headers={"Cache-Control": "max-age=86400"}) @app.get("/api/courbes") def courbes(station_: str = Query(alias="station"), du: str = "", au: str = ""): return station.courbes(station_, du, au) @app.get("/api/detecteurs") def detecteurs(station_: str = Query(alias="station"), du: str = "", au: str = "", cibles: str = ""): return station.detecteurs(station_, du, au, cibles) @app.get("/api/etiquettes") def etiquettes(station_: str = Query(alias="station"), dossier: str = "manual"): try: return station.lire(station_, dossier) except json.JSONDecodeError as e: # une ligne abîmée à la main : le dire, sans toucher au fichier return erreur(500, f"labeling/{dossier}/{station_}.jsonl illisible : {e}") @app.post("/api/etiquettes") def ajouter(corps: dict): return station.ajouter(corps) @app.put("/api/etiquettes") def modifier(corps: dict): return station.modifier(corps) @app.delete("/api/etiquettes") def supprimer(corps: dict): return station.supprimer(corps) if PAGE.is_dir(): app.mount("/", StaticFiles(directory=PAGE, html=True), name="page") else: @app.get("/") def sans_page(): return erreur(503, "la page n'est pas construite : cd app/web && npm install && npm run build") def ouvrir(url: str) -> None: if "microsoft" in platform.uname().release.lower(): # WSL : le navigateur Windows subprocess.Popen(["explorer.exe", url], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) else: webbrowser.open(url) if __name__ == "__main__": url = f"http://127.0.0.1:{PORT}" print(f"Support AIMsight : {url}") if "--sans-navigateur" not in sys.argv: threading.Timer(1, ouvrir, [url]).start() uvicorn.run(app, host="127.0.0.1", port=PORT, log_level="warning", timeout_graceful_shutdown=1)