Flowdeck 7.85.6 — porte centrale unique (phase 2) : écran réduit à l'entrée ObsiGate SSO + porte de secours administrateur par variables d'environnement, désactivée par défaut

app/config.py

@@ -52,6 +52,18 @@ class Settings(BaseSettings):
     # Inscription publique locale : fermée par défaut (décision de
     # Bruno — les comptes naissent dans le Hub Dracodev).
     inscription_locale_ouverte: bool = False
+    # Porte centrale unique (phase 2 du programme « compte partout ») :
+    # désactivée par défaut à la livraison ; même patron de réglage
+    # (la ligne en base prime). Activée, seuls la voie ObsiGate (SSO)
+    # et la porte de secours administrateur ouvrent une session.
+    porte_centrale_active: bool = False
+    # Porte de secours administrateur (porte centrale) — repli des
+    # variables d'environnement FLOWDECK_SECOURS_ADMIN_LOGIN /
+    # FLOWDECK_SECOURS_ADMIN_MOT_DE_PASSE, lues en priorité par
+    # `app/services/reglages_acces.py`. Aucune valeur par défaut :
+    # sans variables posées, la porte de secours est fermée.
+    secours_admin_login: str = ""
+    secours_admin_mot_de_passe: str = ""
 
     # Rate limiting
     rate_limit_enabled: bool = True

app/routers/admin.py

@@ -158,15 +158,23 @@ def get_reglages_acces(_admin=Depends(admin_required)):
 def put_reglages_acces(_admin=Depends(admin_required), body: dict = Body(default={})):
     """Modifie les réglages d'accès — réversible à tout moment.
 
-    Corps accepté : ``{"inscription_locale_ouverte": true|false}``.
-    Fermée (défaut) : aucun compte local ne se crée sur l'instance,
-    les comptes naissent dans le Hub Dracodev. La connexion des
-    comptes existants n'est jamais affectée.
+    Corps accepté : ``{"inscription_locale_ouverte": true|false,
+    "porte_centrale_active": true|false}`` (chaque clé optionnelle).
+    Inscription fermée (défaut) : aucun compte local ne se crée sur
+    l'instance, les comptes naissent dans le Hub Dracodev.
+    Porte centrale (défaut : inactive) : activée, seuls la voie
+    ObsiGate (SSO) et la porte de secours administrateur ouvrent
+    une session.
     """
     from app.services import reglages_acces
+    kwargs = {}
     if "inscription_locale_ouverte" in body:
-        return reglages_acces.set_reglages_acces(
-            inscription_locale_ouverte=bool(body["inscription_locale_ouverte"]))
+        kwargs["inscription_locale_ouverte"] = bool(
+            body["inscription_locale_ouverte"])
+    if "porte_centrale_active" in body:
+        kwargs["porte_centrale_active"] = bool(body["porte_centrale_active"])
+    if kwargs:
+        return reglages_acces.set_reglages_acces(**kwargs)
     return reglages_acces.get_reglages_acces()
 
 

app/routers/auth.py

@@ -94,15 +94,64 @@ body{{background:#191919;color:#fff;font-family:-apple-system,BlinkMacSystemFont
 </html>"""
 
 
-def _rendre_page_connexion(html: str) -> str:
-    """Rend la page de connexion en tenant compte du réglage #146.
+def _page_porte_centrale() -> str:
+    """Écran de connexion en mode porte centrale (phase 2).
 
-    Inscription fermée : l'onglet Register disparaît et un avis nomme
-    le Hub Dracodev (lien dérivé de l'hôte, comme les autres liens de
-    la suite). Inscription ouverte : page intégralement inchangée.
+    Ne présente **que** l'entrée centrale : le bouton ObsiGate (SSO),
+    bien visible. Aucun formulaire local, aucun onglet Register —
+    la porte de secours administrateur passe par le chemin discret
+    ``?secours=1``, jamais proposé ici.
+    """
+    from app.services import draco_urls
+
+    hub = draco_urls.hub_url()
+    return """<!DOCTYPE html>
+<html lang="fr">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>FlowDeck — Connexion</title>
+<style>
+body{background:#191919;color:#fff;font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',sans-serif;display:flex;align-items:center;justify-content:center;min-height:100vh;margin:0;}
+.box{background:#222;border:1px solid rgba(255,255,255,.08);border-radius:12px;padding:40px;width:100%;max-width:400px;}
+.box h1{font-size:24px;margin:0 0 8px;}
+.box p{color:rgba(255,255,255,.55);font-size:14px;line-height:1.6;margin:0 0 20px;}
+.box a{color:#2383E2;}
+.sso{display:flex;align-items:center;justify-content:center;gap:8px;width:100%;padding:14px;border-radius:8px;font-size:15px;font-weight:500;cursor:pointer;border:1px solid rgba(35,131,226,.6);background:#2383E2;color:#fff;text-decoration:none;box-sizing:border-box;}
+.sso:hover{background:#2C8CEB;}
+</style>
+</head>
+<body>
+<div class="box">
+  <h1>FlowDeck</h1>
+  <p>Cette instance n'accepte que la connexion centrale de la suite
+  Dracodev. Les comptes se créent dans le
+  <a href="__HUB_URL__">Hub Dracodev</a>.</p>
+  <a class="sso" href="__SSO_LOGIN_URL__">🧭 Login with ObsiGate (SSO)</a>
+</div>
+</body>
+</html>""".replace("__HUB_URL__", hub)
+
+
+def _rendre_page_connexion(html: str, secours: bool = False) -> str:
+    """Rend la page de connexion en tenant compte des réglages d'accès.
+
+    Porte centrale active (phase 2) : seul l'écran central est rendu
+    — sauf par le chemin discret de secours (``secours=True``), qui
+    rend le formulaire local en marquant ses envois ``secours``.
+    Inscription fermée (#146) : l'onglet Register disparaît et un
+    avis nomme le Hub Dracodev (lien dérivé de l'hôte, comme les
+    autres liens de la suite). Sinon : page intégralement inchangée.
     """
     from app.services import draco_urls, reglages_acces
 
+    if reglages_acces.porte_centrale_active():
+        if not secours:
+            return _with_nonce(_page_porte_centrale())
+        html = html.replace(
+            "const body={email,password};",
+            "const body={email,password,secours:true};")
+        return _with_nonce(html)
     if reglages_acces.inscription_locale_ouverte():
         return _with_nonce(html)
     html = html.replace(
@@ -257,6 +306,9 @@ def register_page(request: Request):
     """
     from app.services import reglages_acces
 
+    if reglages_acces.porte_centrale_active():
+        return HTMLResponse(_with_nonce(_page_porte_centrale()),
+                            status_code=403)
     if not reglages_acces.inscription_locale_ouverte():
         return HTMLResponse(_page_inscription_fermee(), status_code=403)
     return HTMLResponse(_with_nonce(LOCAL_LOGIN_HTML.replace(
@@ -283,7 +335,13 @@ def login(request: Request, provider: str = Query("gitea")):
     # Local login page (POST handled by /auth/local-login)
     from fastapi.responses import HTMLResponse
     if provider == "local":
-        return HTMLResponse(_rendre_page_connexion(LOCAL_LOGIN_HTML), status_code=200)
+        # Chemin discret de la porte de secours (phase 2) :
+        # ?secours=1 rend le formulaire local même en mode porte
+        # centrale — jamais lié depuis l'écran principal.
+        secours = request.query_params.get("secours") == "1"
+        return HTMLResponse(
+            _rendre_page_connexion(LOCAL_LOGIN_HTML, secours=secours),
+            status_code=200)
 
     # OAuth flow — check if provider is configured
     from app.auth.providers import get_provider
@@ -341,6 +399,13 @@ def register(request: Request, body: dict = Body(default={})):
     # naissent dans le Hub Dracodev — aucun compte local ne se crée
     # ici. La connexion des comptes existants n'est pas touchée.
     from app.services import draco_urls, reglages_acces
+    if reglages_acces.porte_centrale_active():
+        from fastapi.responses import JSONResponse
+        return JSONResponse(
+            {"error": reglages_acces.message_porte_centrale(),
+             "hub_url": draco_urls.hub_url()},
+            status_code=403,
+        )
     if not reglages_acces.inscription_locale_ouverte():
         from fastapi.responses import JSONResponse
         return JSONResponse(
@@ -400,6 +465,34 @@ def local_login(request: Request, body: dict = Body(default={})):
     if not email or not password:
         return JSONResponse({"error": "Email and password required"}, status_code=400)
 
+    # Porte centrale unique (phase 2) : les identifiants locaux
+    # ordinaires ne sont plus acceptés — comptes historiques inclus.
+    # Seule exception : la porte de secours administrateur, par le
+    # drapeau explicite `secours` (posé par le chemin discret) et les
+    # identifiants des variables d'environnement. Les sessions déjà
+    # établies ne passent pas par ici et ne sont pas touchées.
+    from app.services import reglages_acces as _reglages_acces
+    if _reglages_acces.porte_centrale_active():
+        if not body.get("secours"):
+            return JSONResponse(
+                {"error": _reglages_acces.message_porte_centrale()},
+                status_code=403,
+            )
+        compte_secours = _reglages_acces.authentifier_secours(email, password)
+        if compte_secours is None:
+            return JSONResponse(
+                {"error": "Porte de secours : identifiants invalides."},
+                status_code=401,
+            )
+        session = SessionManager.create_session(compte_secours, request)
+        _log_login(compte_secours["id"], request)
+        response = JSONResponse({"status": "ok", "user": {
+            "login": compte_secours["login"],
+            "name": compte_secours["full_name"]}})
+        response.set_cookie("flowdeck_session", session, httponly=True,
+                            max_age=86400 * 7, samesite="lax", path="/")
+        return response
+
     with get_conn() as conn:
         user = conn.execute("SELECT * FROM users WHERE login=?", (email,)).fetchone()
     if not user:

app/services/reglages_acces.py

@@ -1,4 +1,5 @@
-"""Réglages d'accès de l'instance — inscription locale (fusion #146).
+"""Réglages d'accès de l'instance — inscription locale (fusion #146)
+et porte centrale unique (phase 2 du programme « compte partout »).
 
 Patron des réglages existants (``llm_config``, ``sso_config``) : une
 table à ligne unique (``id = 1``) créée paresseusement, qui prime sur
@@ -16,12 +17,32 @@ Réglage « inscription locale ouverte » :
   ``INSCRIPTION_LOCALE_OUVERTE=true`` avant tout enregistrement en
   base.
 
-Ce réglage ne touche **jamais** la connexion des comptes existants,
-locaux comme draco : il ne garde que la création de comptes locaux.
+Le réglage d'inscription ne touche **jamais** la connexion des
+comptes existants, locaux comme draco : il ne garde que la création
+de comptes locaux.
+
+Réglage « porte centrale » (phase 2, **distinct** du précédent) :
+
+- **désactivé par défaut à la livraison** ; activé par un
+  administrateur, l'écran de connexion ne présente que l'entrée
+  centrale (bouton ObsiGate SSO) et les identifiants locaux
+  ordinaires ne sont plus acceptés — y compris pour les comptes
+  locaux historiques. Les sessions déjà établies ne sont pas
+  touchées, et la voie draco (SSO/JIT) reste la porte normale.
+- **Porte de secours administrateur** : UN compte administrateur
+  local désigné peut encore s'authentifier localement, uniquement
+  par le chemin discret ``/auth/login?provider=local&secours=1``
+  (jamais proposé sur l'écran principal). Ses identifiants sont
+  posés par les variables d'environnement
+  ``FLOWDECK_SECOURS_ADMIN_LOGIN`` et
+  ``FLOWDECK_SECOURS_ADMIN_MOT_DE_PASSE`` — aucun secret en dur ;
+  sans ces variables, la porte de secours est fermée.
 """
 from __future__ import annotations
 
 import logging
+import os
+import secrets
 
 from app.config import settings
 
@@ -32,18 +53,27 @@ __all__ = [
     "set_reglages_acces",
     "inscription_locale_ouverte",
     "message_inscription_fermee",
+    "porte_centrale_active",
+    "message_porte_centrale",
+    "authentifier_secours",
 ]
 
 
 def _assurer_table(conn) -> None:
-    """Crée la table des réglages d'accès si elle n'existe pas encore."""
+    """Crée la table des réglages d'accès si elle n'existe pas encore
+    et y ajoute les colonnes des phases ultérieures si besoin."""
     conn.execute("""
         CREATE TABLE IF NOT EXISTS reglages_acces (
             id INTEGER PRIMARY KEY CHECK (id = 1),
             inscription_locale_ouverte INTEGER,
+            porte_centrale_active INTEGER,
             updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
         )
     """)
+    colonnes = {r[1] for r in conn.execute("PRAGMA table_info(reglages_acces)")}
+    if "porte_centrale_active" not in colonnes:
+        conn.execute(
+            "ALTER TABLE reglages_acces ADD COLUMN porte_centrale_active INTEGER")
 
 
 def get_reglages_acces() -> dict:
@@ -52,6 +82,9 @@ def get_reglages_acces() -> dict:
         # Défaut du code et de la config : inscription fermée.
         "inscription_locale_ouverte": bool(
             getattr(settings, "inscription_locale_ouverte", False)),
+        # Défaut du code et de la config : porte centrale désactivée.
+        "porte_centrale_active": bool(
+            getattr(settings, "porte_centrale_active", False)),
     }
     try:
         from app.db import get_conn
@@ -59,33 +92,43 @@ def get_reglages_acces() -> dict:
         with get_conn() as conn:
             _assurer_table(conn)
             row = conn.execute(
-                "SELECT inscription_locale_ouverte FROM reglages_acces"
-                " WHERE id=1"
+                "SELECT inscription_locale_ouverte, porte_centrale_active"
+                " FROM reglages_acces WHERE id=1"
             ).fetchone()
     except Exception:  # noqa: BLE001 — base pas encore prête → config seule
         return reglages
-    if row is not None and row["inscription_locale_ouverte"] is not None:
-        reglages["inscription_locale_ouverte"] = bool(
-            row["inscription_locale_ouverte"])
+    if row is not None:
+        if row["inscription_locale_ouverte"] is not None:
+            reglages["inscription_locale_ouverte"] = bool(
+                row["inscription_locale_ouverte"])
+        if row["porte_centrale_active"] is not None:
+            reglages["porte_centrale_active"] = bool(
+                row["porte_centrale_active"])
     return reglages
 
 
-def set_reglages_acces(*, inscription_locale_ouverte: bool | None = None) -> dict:
+def set_reglages_acces(*, inscription_locale_ouverte: bool | None = None,
+                       porte_centrale_active: bool | None = None) -> dict:
     """Enregistre les réglages d'accès (ligne unique) et les renvoie."""
     from app.db import get_conn
 
     actuels = get_reglages_acces()
     if inscription_locale_ouverte is not None:
         actuels["inscription_locale_ouverte"] = bool(inscription_locale_ouverte)
+    if porte_centrale_active is not None:
+        actuels["porte_centrale_active"] = bool(porte_centrale_active)
     with get_conn() as conn:
         _assurer_table(conn)
         conn.execute(
             "INSERT INTO reglages_acces (id, inscription_locale_ouverte,"
-            " updated_at) VALUES (1, ?, CURRENT_TIMESTAMP)"
+            " porte_centrale_active, updated_at) VALUES (1, ?, ?,"
+            " CURRENT_TIMESTAMP)"
             " ON CONFLICT(id) DO UPDATE SET"
             " inscription_locale_ouverte=excluded.inscription_locale_ouverte,"
+            " porte_centrale_active=excluded.porte_centrale_active,"
             " updated_at=CURRENT_TIMESTAMP",
-            (1 if actuels["inscription_locale_ouverte"] else 0,),
+            (1 if actuels["inscription_locale_ouverte"] else 0,
+             1 if actuels["porte_centrale_active"] else 0),
         )
         conn.commit()
     return actuels
@@ -96,6 +139,65 @@ def inscription_locale_ouverte() -> bool:
     return bool(get_reglages_acces()["inscription_locale_ouverte"])
 
 
+def porte_centrale_active() -> bool:
+    """Vrai si la porte centrale unique est active sur l'instance."""
+    return bool(get_reglages_acces()["porte_centrale_active"])
+
+
+def message_porte_centrale() -> str:
+    """Message affiché quand la porte centrale refuse le local."""
+    from app.services import draco_urls
+
+    return (
+        "La porte centrale est active sur cette instance : "
+        "connectez-vous avec le bouton « Login with ObsiGate (SSO) » "
+        "— les comptes se créent dans le Hub Dracodev "
+        f"({draco_urls.hub_url()})."
+    )
+
+
+def _secours_identifiants() -> tuple[str, str]:
+    """Identifiants de la porte de secours — variables d'environnement
+    en priorité, repli sur la configuration. Jamais de valeur par
+    défaut : vide = porte de secours fermée."""
+    login = (os.environ.get("FLOWDECK_SECOURS_ADMIN_LOGIN", "")
+             or getattr(settings, "secours_admin_login", "") or "").strip()
+    mot_de_passe = (os.environ.get("FLOWDECK_SECOURS_ADMIN_MOT_DE_PASSE", "")
+                    or getattr(settings, "secours_admin_mot_de_passe", "") or "")
+    return login, mot_de_passe
+
+
+def authentifier_secours(login: str, mot_de_passe: str) -> dict | None:
+    """Authentifie le compte administrateur de secours désigné.
+
+    Les identifiants fournis doivent correspondre **exactement** aux
+    variables d'environnement de la porte de secours (comparaison à
+    temps constant), et le compte local correspondant doit exister,
+    être actif et être administrateur. Renvoie le compte (dict) ou
+    ``None`` — sans jamais dire quelle condition a échoué.
+    """
+    attendu_login, attendu_mdp = _secours_identifiants()
+    if not attendu_login or not attendu_mdp:
+        return None
+    if not secrets.compare_digest((login or "").strip(), attendu_login):
+        return None
+    if not secrets.compare_digest(mot_de_passe or "", attendu_mdp):
+        return None
+    from app.db import get_conn
+
+    with get_conn() as conn:
+        row = conn.execute(
+            "SELECT * FROM users WHERE login=? OR email=?",
+            (attendu_login, attendu_login),
+        ).fetchone()
+    if row is None:
+        return None
+    compte = dict(row)
+    if not compte.get("is_admin") or not compte.get("is_active"):
+        return None
+    return compte
+
+
 def message_inscription_fermee() -> str:
     """Message affiché quand l'inscription locale est fermée (#146).