diff --git a/beta/server.py b/beta/server.py
new file mode 100644
index 0000000..0536b1b
--- /dev/null
+++ b/beta/server.py
@@ -0,0 +1,422 @@
+"""Serveur de la bêta JobRunner (bibliothèque standard uniquement).
+
+Sert le site statique du dépôt derrière une porte d'entrée par code d'accès,
+injecte le bandeau « Bêta » et le bouton « Donner mon avis », et expose une
+petite API locale (entrée, retours, formulaire testeur, flux de démo).
+
+Lancement local : python beta/server.py (127.0.0.1:8830 par défaut)
+Aucun appel sortant, aucun paiement, aucune clé.
+"""
+import base64
+import hashlib
+import json
+import mimetypes
+import os
+import re
+import secrets
+import sys
+import threading
+import time
+import unicodedata
+from datetime import date
+from http import cookies
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+from urllib.parse import unquote, urlsplit
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import db # noqa: E402
+
+RACINE = Path(__file__).resolve().parent.parent
+STATIC = Path(__file__).resolve().parent / "static"
+COOKIE = "jrb_s"
+SESSION_S = 7 * 86400
+FENETRE_S = 15 * 60
+MAX_ECHECS_IP = int(os.environ.get("BETA_MAX_ECHECS_IP", "6"))
+MAX_ECHECS_GLOBAL = int(os.environ.get("BETA_MAX_ECHECS_GLOBAL", "60"))
+FAIT_CONFIANCE_PROXY = os.environ.get("BETA_TRUST_PROXY") == "1"
+EXT_OK = {".html", ".css", ".js", ".woff2", ".png", ".jpg", ".jpeg", ".svg", ".webp", ".ico", ".mp4", ".webm", ".gif", ".pdf"}
+DOSSIERS_INTERDITS = {"beta", ".git", "docs", "node_modules", "design"}
+CSP_APP = ("default-src 'self'; img-src 'self' https: data: blob:; media-src 'self' https: blob:; "
+ "style-src 'self' 'unsafe-inline'; script-src 'self' 'unsafe-inline'; font-src 'self' data:; "
+ "connect-src 'self'; frame-src 'none'; object-src 'none'; base-uri 'self'; form-action 'self'")
+CSP_PAGE = ("default-src 'self'; img-src 'self' data:; style-src 'self' 'unsafe-inline'; "
+ "script-src 'self' 'unsafe-inline'; font-src 'self'; connect-src 'self'; frame-ancestors 'none'; "
+ "base-uri 'none'; form-action 'self'")
+INJECTION = (''
+ '')
+EMAIL = re.compile(r"^[^@\s]{1,64}@[^@\s]{1,190}\.[^@\s]{2,}$")
+TEL = re.compile(r"^[0-9 +().-]{6,20}$")
+
+
+LOGOS = {"logo.png", "logo-official.jpg", "logo-square.png", "logo-transparent.png",
+ "logo-dark.svg", "logo-j.svg", "logo-light.svg"}
+
+
+def chemin_sur(p):
+ """Refuse tout segment '.' ou '..' (y compris encodé, même doublement), antislash, NUL, % résiduel."""
+ q = p
+ for _ in range(3):
+ q = unquote(q)
+ if "%" in q or "\\" in q or "\x00" in q or any(ord(ch) < 32 for ch in q):
+ return False
+ return not any(seg in (".", "..") for seg in p.split("/") + q.split("/"))
+
+
+def a_controle(v):
+ return any(unicodedata.category(ch)[0] == "C" for ch in str(v))
+
+
+def age(naissance, ref=None):
+ ref = ref or date.today()
+ y, m, d = (int(x) for x in naissance.split("-"))
+ return ref.year - y - ((ref.month, ref.day) < (m, d))
+
+
+class Handler(BaseHTTPRequestHandler):
+ server_version = "JobRunnerBeta"
+ sys_version = ""
+
+ def log_message(self, fmt, *a): # pas de journal HTTP (ni IP ni cookie) sauf demande
+ if os.environ.get("BETA_VERBOSE"):
+ sys.stderr.write("[beta] " + fmt % a + "\n")
+
+ # --- utilitaires -------------------------------------------------
+ @property
+ def c(self):
+ return self.server.conn
+
+ def ip(self):
+ if FAIT_CONFIANCE_PROXY:
+ xf = self.headers.get("X-Forwarded-For", "")
+ if xf:
+ return xf.split(",")[-1].strip() # dernier saut = ajouté par Caddy
+ return self.client_address[0]
+
+ def https(self):
+ return FAIT_CONFIANCE_PROXY and self.headers.get("X-Forwarded-Proto") == "https"
+
+ def envoyer(self, code, corps=b"", ctype="text/html; charset=utf-8", extra=None, csp=CSP_PAGE):
+ if isinstance(corps, str):
+ corps = corps.encode()
+ self.send_response(code)
+ self.send_header("Content-Type", ctype)
+ self.send_header("Content-Length", str(len(corps)))
+ self.send_header("X-Content-Type-Options", "nosniff")
+ self.send_header("Referrer-Policy", "no-referrer")
+ self.send_header("X-Robots-Tag", "noindex, nofollow")
+ if not any(k.lower() == "cache-control" for k, _ in (extra or [])):
+ self.send_header("Cache-Control", "no-store")
+ if csp:
+ self.send_header("Content-Security-Policy", csp)
+ for k, v in (extra or []):
+ self.send_header(k, v)
+ self.end_headers()
+ if self.command != "HEAD":
+ self.wfile.write(corps)
+
+ def json(self, code, obj, extra=None):
+ self.envoyer(code, json.dumps(obj, ensure_ascii=False), "application/json; charset=utf-8", extra)
+
+ def corps_json(self, limite=32_000):
+ n = int(self.headers.get("Content-Length") or 0)
+ if n <= 0 or n > limite:
+ return None
+ try:
+ return json.loads(self.rfile.read(n))
+ except Exception:
+ return None
+
+ def session(self):
+ brut = self.headers.get("Cookie", "")
+ try:
+ tok = cookies.SimpleCookie(brut)[COOKIE].value
+ except Exception:
+ return None
+ h = hashlib.sha256(tok.encode()).hexdigest()
+ now = time.time()
+ s = self.c.execute("SELECT * FROM sessions WHERE token_hash=? AND expires_at>?", (h, now)).fetchone()
+ if not s:
+ return None
+ code = self.c.execute("SELECT * FROM codes WHERE id=?", (s["code_id"],)).fetchone()
+ if not code or not db.code_actif(code, now): # révocation / expiration immédiates
+ return None
+ return {"hash": h, "code": code}
+
+ def csrf_ok(self):
+ if self.headers.get("X-Beta") != "1":
+ return False
+ o = self.headers.get("Origin")
+ return not o or urlsplit(o).netloc == self.headers.get("Host")
+
+ def bloque(self, iph):
+ now = time.time()
+ n_ip = self.c.execute("SELECT COUNT(*) FROM attempts WHERE ip_hash=? AND ok=0 AND ts>?", (iph, now - FENETRE_S)).fetchone()[0]
+ n_all = self.c.execute("SELECT COUNT(*) FROM attempts WHERE ok=0 AND ts>?", (now - 3600,)).fetchone()[0]
+ return n_ip >= MAX_ECHECS_IP or n_all >= MAX_ECHECS_GLOBAL
+
+ # --- routage -----------------------------------------------------
+ def do_HEAD(self):
+ self.do_GET()
+
+ def do_GET(self):
+ with self.server.verrou:
+ self._get()
+
+ def do_POST(self):
+ with self.server.verrou:
+ self._post()
+
+ def _get(self):
+ p = urlsplit(self.path).path
+ if not chemin_sur(p):
+ return self.envoyer(404, "Introuvable", "text/plain; charset=utf-8")
+ if p == "/robots.txt":
+ return self.envoyer(200, "User-agent: *\nDisallow: /\n", "text/plain")
+ if p == "/__beta/healthz":
+ return self.json(200, {"ok": True})
+ if p == "/__beta/gate":
+ return self.envoyer(200, (STATIC / "gate.html").read_bytes())
+ if p == "/__beta/formulaire":
+ return self.envoyer(200, (STATIC / "formulaire.html").read_bytes())
+ if p.startswith("/__beta/static/"):
+ return self.fichier(STATIC, p[len("/__beta/static/"):], cache=True)
+ if p.startswith("/assets/fonts/"): # polices : dossier fixe, woff2 uniquement
+ return self.fichier(RACINE / "assets" / "fonts", p[len("/assets/fonts/"):], ext=".woff2")
+ if p == "/assets/css/fonts.css":
+ return self.fichier(RACINE / "assets" / "css", "fonts.css")
+ if p.startswith("/assets/img/") and p[len("/assets/img/"):] in LOGOS: # logos : liste blanche
+ return self.fichier(RACINE / "assets" / "img", p[len("/assets/img/"):])
+ s = self.session()
+ if not s:
+ if p.endswith(".html") or p == "/":
+ return self.envoyer(302, b"", extra=[("Location", "/__beta/gate")])
+ return self.envoyer(401, "Accès réservé aux testeurs.", "text/plain; charset=utf-8")
+ if p.startswith("/__beta/avatar/"):
+ return self.avatar(p[len("/__beta/avatar/"):])
+ if p == "/__beta/api/demo":
+ return self.json(200, self.flux_demo())
+ if p == "/__beta/api/me":
+ return self.json(200, {"label": s["code"]["label"]})
+ if p == "/__beta/logout":
+ return self.deconnecter(s)
+ if p.startswith("/__beta/"):
+ return self.envoyer(404, "Introuvable", "text/plain; charset=utf-8")
+ self.fichier(RACINE, p.lstrip("/") or "index.html", app=True)
+
+ def _post(self):
+ p = urlsplit(self.path).path
+ if not chemin_sur(p):
+ return self.json(404, {"erreur": "inconnu"})
+ if not self.csrf_ok():
+ return self.json(403, {"erreur": "requête refusée"})
+ if p == "/__beta/api/enter":
+ return self.entrer()
+ if p == "/__beta/api/tester":
+ return self.formulaire_testeur()
+ s = self.session()
+ if not s:
+ return self.json(401, {"erreur": "session expirée, ressaisir le code"})
+ if p == "/__beta/api/feedback":
+ return self.retour(s)
+ self.json(404, {"erreur": "inconnu"})
+
+ # --- fichiers ----------------------------------------------------
+ def fichier(self, base, rel, cache=False, app=False, ext=None):
+ try:
+ if "\x00" in rel or "\\" in rel:
+ raise ValueError
+ cible = (base / rel).resolve()
+ parties = cible.relative_to(base.resolve()).parts
+ except Exception:
+ return self.envoyer(404, "Introuvable", "text/plain; charset=utf-8")
+ if app and (not parties or parties[0] in DOSSIERS_INTERDITS or any(x.startswith(".") for x in parties)):
+ return self.envoyer(404, "Introuvable", "text/plain; charset=utf-8")
+ if not cible.is_file() or cible.suffix.lower() not in EXT_OK or (ext and cible.suffix.lower() != ext):
+ return self.envoyer(404, "Introuvable", "text/plain; charset=utf-8")
+ data = cible.read_bytes()
+ suf = cible.suffix.lower()
+ ctype = mimetypes.guess_type(cible.name)[0] or "application/octet-stream"
+ if suf == ".html":
+ txt = data.decode("utf-8", "replace")
+ if app:
+ txt = txt.replace("