API: the support page becomes a web app, React with Mantine and FastAPI (D-137)

Same features as the local page; agents, tools, prompts and knowledge unchanged.
- API/web/: React (Vite) with Mantine components: collapsible sidebar, mobile drawer,
  cards, notifications, dark mode
- API/support/serveur.py: FastAPI serves the built page and /api; agent events pushed
  by server-sent events (/api/flux) instead of polling
- data, cases folder and port set by AIMSIGHT_DATA, AIMSIGHT_CASES, AIMSIGHT_PORT
- check.py: server check (host guard, analyse, stream, PDF) with a fake client
- old page.html removed

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
maximeandClaude Opus 5.5 committed 2026-11-05 14:03:52 +01:00
1 parent eb10a6b735
commit b0245c4067
17 files changed
+1666 -263

No files matched your search

+107 -86
View File
@@ -1,26 +1,35 @@
"""La page support : API/.venv/bin/python API/support/serveur.py → http://127.0.0.1:8770
"""La web app support : API/.venv/bin/python API/support/serveur.py → http://127.0.0.1:8770
Une séance à la fois, en mémoire ; la page interroge /evenements chaque seconde.
Le serveur FastAPI sert la page React construite (API/web/dist, `npm run build` dans API/web) et l'API sous /api.
Une séance à la fois, en mémoire ; /api/flux pousse à la page les événements des agents (server-sent events).
Réglages : AIMSIGHT_DATA (données), 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 http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from pathlib import Path
from urllib.parse import parse_qs, urlparse
import uvicorn
from fastapi import FastAPI, Request
from fastapi.responses import FileResponse, JSONResponse, StreamingResponse
from fastapi.staticfiles import StaticFiles
sys.path.insert(0, str(Path(__file__).resolve().parent))
from seance import Seance, donnees_par_defaut # noqa: E402
from seance import API, Seance, donnees_par_defaut # noqa: E402
PORT = 8770
HOTES = {f"127.0.0.1:{PORT}", f"localhost:{PORT}"} # contre le DNS rebinding : un autre site ne lit ni mails ni PDF
PAGE = Path(__file__).resolve().parent / "page.html"
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 = API / "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:
@@ -37,85 +46,98 @@ def en_fond(f, *args):
threading.Thread(target=lancer, daemon=True).start()
class Serveur(BaseHTTPRequestHandler):
def log_message(self, *_):
pass
def erreur(code: int, texte: str) -> JSONResponse:
return JSONResponse({"erreur": texte}, code)
def _envoyer(self, code: int, corps: bytes, type_: str = "application/json", plus: dict | None = None):
self.send_response(code)
self.send_header("Content-Type", type_)
self.send_header("Content-Length", str(len(corps)))
for k, v in (plus or {}).items():
self.send_header(k, v)
self.end_headers()
self.wfile.write(corps)
def _json(self, code: int, obj) -> None:
self._envoyer(code, json.dumps(obj, ensure_ascii=False).encode())
@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 == "POST"
and not request.headers.get("content-type", "").startswith("application/json")):
return erreur(403, "requête refusée")
return await suite(request)
def _refuse(self, post: bool = False) -> bool:
"""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)."""
if self.headers.get("Host") not in HOTES or (
post and not self.headers.get("Content-Type", "").startswith("application/json")):
self._json(403, {"erreur": "requête refusée"})
return True
return False
def do_GET(self):
if self._refuse():
return
url = urlparse(self.path)
s = etat["seance"]
if url.path == "/":
return self._envoyer(200, PAGE.read_bytes(), "text/html; charset=utf-8")
if url.path == "/evenements":
depuis = int(parse_qs(url.query).get("depuis", ["0"])[0])
with verrou:
evs = etat["evenements"][depuis:]
n = len(etat["evenements"])
v = s.derniere_version() if s else None
return self._json(200, {"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,
"occupe": {a: bool(s and s.occupe(a)) for a in ("support", "analyste")}})
if url.path == "/pdf":
v = s.derniere_version() if s else None
if not v:
return self._json(404, {"erreur": "pas encore de PDF"})
nom = f"{s.dossier.name}_{v.name}"
return self._envoyer(200, v.read_bytes(), "application/pdf",
{"Content-Disposition": f'inline; filename="{nom}"'})
self._json(404, {"erreur": url.path})
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,
"occupe": {a: bool(s and s.occupe(a)) for a in ("support", "analyste")}}
def do_POST(self):
if self._refuse(post=True):
return
corps = json.loads(self.rfile.read(int(self.headers.get("Content-Length", 0))) or b"{}")
s = etat["seance"]
if self.path == "/analyser":
if s and (s.occupe("support") or s.occupe("analyste")):
return self._json(409, {"erreur": "une séance travaille encore"})
if not corps.get("mail", "").strip():
return self._json(400, {"erreur": "le mail est vide"})
images = [(i["type"], base64.b64decode(i["base64"])) for i in corps.get("images", [])]
with verrou:
etat["evenements"] = []
etat["seance"] = s = Seance(corps["mail"], images, corps.get("contexte", ""), donnees_par_defaut(),
journal)
en_fond(s.demarrer)
return self._json(200, {"dossier": s.dossier.name})
if self.path == "/message":
agent, texte = corps.get("agent"), corps.get("texte", "").strip()
if not s:
return self._json(400, {"erreur": "pas de séance : coller un mail et Analyser"})
if agent not in ("support", "analyste") or not texte:
return self._json(400, {"erreur": "agent ou texte manquant"})
if s.occupe(agent):
return self._json(409, {"erreur": f"{agent} occupé"})
en_fond(s.parler, agent, texte)
return self._json(200, {})
self._json(404, {"erreur": self.path})
@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:
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.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")
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)
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 {}
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 API/web && npm install && npm run build")
def ouvrir(url: str) -> None:
@@ -127,8 +149,7 @@ def ouvrir(url: str) -> None:
if __name__ == "__main__":
url = f"http://127.0.0.1:{PORT}"
serveur = ThreadingHTTPServer(("127.0.0.1", PORT), Serveur)
print(f"Page support : {url}")
print(f"Support AIMsight : {url}")
if "--sans-navigateur" not in sys.argv:
ouvrir(url)
serveur.serve_forever()
threading.Timer(1, ouvrir, [url]).start()
uvicorn.run(app, host="127.0.0.1", port=PORT, log_level="warning", timeout_graceful_shutdown=1)