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

CHANGELOG.md

@@ -1,3 +1,20 @@
+## v7.85.6 (2026-11-06) — Porte centrale unique (phase 2 du programme « compte partout »), désactivée par défaut
+
+> Branche basée sur la 7.85.5 (phase 1, #146/#144) — PR distincte, à fusionner après elle.
+
+- **Nouveau réglage « porte centrale »** (`porte_centrale_active` dans `app/services/reglages_acces.py`, même patron que le réglage d'inscription de la phase 1, **distinct** de lui, **désactivé par défaut à la livraison** ; activable/désactivable par un administrateur via `GET`/`PUT /api/admin/reglages-acces` ou la variable `PORTE_CENTRALE_ACTIVE`).
+- **Mode actif** : l'écran de connexion ne présente que l'entrée centrale — le bouton « Login with ObsiGate (SSO) », bien visible, et le lien vers le Hub Dracodev où les comptes se créent (URL dérivée de l'hôte). `POST /auth/local-login` refuse les identifiants locaux ordinaires (403, message nommant la voie SSO), **y compris pour les comptes locaux historiques** ; l'inscription est également fermée dans ce mode. 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 `GET /auth/login?provider=local&secours=1` (le formulaire y marque ses envois `secours` ; 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` (comparaison à temps constant ; le compte local correspondant doit exister, être actif et administrateur ; aucun secret en dur, aucune valeur par défaut — sans variables, la porte est fermée).
+- **Mode inactif** : comportement actuel intégralement préservé (formulaire local, inscription selon le réglage de la phase 1).
+- **Tests** : `tests/test_porte_centrale.py` (nouveau, 15 tests) — défaut désactivé vérifié dans le code, réglage distinct de celui d'inscription, refus du compte ordinaire et du compte historique en mode actif, écran réduit à l'entrée centrale (aucun formulaire, aucun « secours »), inscription fermée en mode actif, session établie préservée, secours : écran discret, connexion admin réussie, mauvais mot de passe refusé, absence de drapeau refusée, compte non-admin désigné refusé, absence de variables = porte fermée ; mode inactif = comportement actuel ; aller-retour de l'API d'administration.
+
+## v7.85.5 (2026-11-06) — Inscription locale fermée par défaut + échec de connexion qui nomme la voie SSO (fusion #146, #144)
+
+- **#146 — l'inscription publique locale n'est plus ouverte par défaut** : nouveau réglage d'administration « inscription locale ouverte » (`app/services/reglages_acces.py`, patron `llm_config`/`sso_config` : ligne unique en base qui prime sur la variable `INSCRIPTION_LOCALE_OUVERTE`, défaut **fermée** — décision de Bruno : les comptes naissent dans le Hub Dracodev). Réversible à tout moment par un administrateur via `GET`/`PUT /api/admin/reglages-acces`.
+- **Quand elle est fermée** : `POST /auth/register` répond 403 et `GET /auth/register` affiche une page de refus propre en français — les comptes se créent dans le Hub Dracodev, avec le lien du Hub dérivé de l'hôte (`draco_urls.hub_url()`, comme les autres liens de la suite) ; l'onglet Register disparaît de l'écran de connexion (avis nommant le Hub à la place) et les boutons « Get started » de la page d'accueil cèdent la place au lien Hub. **La connexion des comptes existants, locaux comme draco, n'est jamais affectée.**
+- **#144 (part Flowdeck)** : l'échec du formulaire de connexion locale (« Invalid credentials », 401) suggère désormais la voie centrale : « Si votre compte a été créé dans le Hub Dracodev, connectez-vous avec le bouton « Login with ObsiGate (SSO) »… » — le bouton existant, dont le libellé est repris tel quel. Aucune logique d'authentification ne change.
+- **Tests** : `tests/test_reglages_acces.py` (nouveau, 12 tests) — fermée par défaut (défaut du code vérifié), POST refusé 403 + message + aucun compte créé, page de refus, onglet Register absent, ouverte = inscription d'aujourd'hui, connexion des comptes existants (local et draco) inchangée ouvert/fermé, échec local nommant ObsiGate (SSO), aller-retour de l'API d'administration et refus aux anonymes. Le harnais de test ouvre explicitement l'inscription pour les suites historiques qui créent leurs comptes par `/auth/register` (conftest et les fixtures locales des suites historiques, commenté).
+
 ## v7.85.4 (2026-11-06) — Barre commune v0.6.0 re-vendangée : entrée « Administration » (fusion #142)
 
 - **Re-vendange verbatim** de la barre commons v0.6.0 (PR dracodev-commons #14) : `static/js/vendor/draco-barre.js` + `static/css/draco-barre.css`. Le menu compte gagne l'entrée **Administration** → `<hub>/admin` (le Hub redirige vers `/admin/utilisateurs`), à **visibilité conditionnelle** (affirmée par l'hôte via `cfg.admin` / `DRACO_BAR.setAdmin`, jamais déduite par la barre).

VERSION

@@ -1 +1 @@
-7.85.4
+7.85.6

app/config.py

@@ -46,6 +46,25 @@ class Settings(BaseSettings):
     log_level: str = "INFO"
     default_lang: str = "fr"
 
+    # Réglages d'accès (fusion #146) — défauts repris par
+    # `app/services/reglages_acces.py` ; la ligne enregistrée en base
+    # par un administrateur prime sur ces valeurs.
+    # 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
     rate_limit_requests: int = 60  # per minute

app/routers/admin.py

@@ -146,6 +146,38 @@ def delete_user(user_id: int, _admin=Depends(admin_required)):
     return {"status": "ok"}
 
 
+# ── Réglages d'accès (fusion #146) ──
+@router.get("/reglages-acces")
+def get_reglages_acces(_admin=Depends(admin_required)):
+    """Réglages d'accès effectifs de l'instance (administrateurs)."""
+    from app.services import reglages_acces
+    return reglages_acces.get_reglages_acces()
+
+
+@router.put("/reglages-acces")
+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,
+    "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:
+        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()
+
+
 # ── Stats ──
 @router.get("/stats")
 def user_stats(_admin=Depends(admin_required)):

app/routers/auth.py

@@ -51,6 +51,125 @@ def _sso_login_url() -> str:
             f"?return_to={quote(retour, safe='')}")
 
 
+# Échec de connexion locale (fusion #144) : le message suggère la voie
+# centrale — un compte créé dans le Hub Dracodev n'a pas de mot de
+# passe local, son entrée est le bouton « Login with ObsiGate (SSO) »
+# du même écran (libellé repris tel quel).
+MESSAGE_ECHEC_CONNEXION_LOCALE = (
+    "Identifiants invalides. Si votre compte a été créé dans le Hub "
+    "Dracodev, connectez-vous avec le bouton « Login with ObsiGate "
+    "(SSO) » de cet écran : les comptes de la suite n'ont pas de mot "
+    "de passe local."
+)
+
+
+def _page_inscription_fermee() -> str:
+    """Page de refus propre du parcours d'inscription fermé (#146)."""
+    from app.services import draco_urls, reglages_acces
+
+    hub = draco_urls.hub_url()
+    message = reglages_acces.message_inscription_fermee()
+    return f"""<!DOCTYPE html>
+<html lang="fr">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>FlowDeck — Inscription fermée</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:420px;}}
+.box h1{{font-size:22px;margin:0 0 12px;}}
+.box p{{color:rgba(255,255,255,.6);font-size:14px;line-height:1.6;margin:0 0 16px;}}
+.box a{{color:#2383E2;}}
+</style>
+</head>
+<body>
+<div class="box">
+  <h1>Inscription fermée</h1>
+  <p>{message}</p>
+  <p><a href="{hub}">Ouvrir le Hub Dracodev</a> ·
+     <a href="/auth/login?provider=local">Retour à la connexion</a></p>
+</div>
+</body>
+</html>"""
+
+
+def _page_porte_centrale() -> str:
+    """Écran de connexion en mode porte centrale (phase 2).
+
+    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(
+        """<button class="tab" onclick="switchTab('register')" id="tab-register">Register</button>""",
+        "",
+    )
+    avis = (
+        '<div class="success" style="display:block;'
+        'background:rgba(35,131,226,.15);color:#7db8f0">'
+        "Pas encore de compte ? Les comptes se créent dans le "
+        f'<a href="{draco_urls.hub_url()}" style="color:#7db8f0">'
+        "Hub Dracodev</a>, puis se connectent ici avec le bouton "
+        "« Login with ObsiGate (SSO) ».</div>"
+    )
+    html = html.replace('<div id="expired-msg"', avis + '<div id="expired-msg"', 1)
+    return _with_nonce(html)
+
+
 def _with_nonce(html: str) -> str:
     """A20 : injecte le nonce CSP au moment du rendu.
 
@@ -180,7 +299,18 @@ async function handleLogin(e){e.preventDefault();const email=document.getElement
 
 @router.get("/register")
 def register_page(request: Request):
-    """Show the registration page (local login page with register tab active)."""
+    """Show the registration page (local login page with register tab active).
+
+    Inscription fermée (#146, défaut) : refus propre — page en
+    français nommant le Hub Dracodev, là où les comptes se créent.
+    """
+    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(
         'class="tab active" onclick="switchTab(\'login\')"',
         'class="tab" onclick="switchTab(\'login\')"'
@@ -205,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(_with_nonce(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
@@ -259,6 +395,25 @@ def register(request: Request, body: dict = Body(default={})):
         from fastapi.responses import JSONResponse
         return JSONResponse({"error": "Password must be at least 6 characters"}, status_code=400)
 
+    # Inscription locale fermée (fusion #146, défaut) : les comptes
+    # 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(
+            {"error": reglages_acces.message_inscription_fermee(),
+             "hub_url": draco_urls.hub_url()},
+            status_code=403,
+        )
+
     # SSO-only instance (v6.7.0): local registration is refused — accounts are
     # auto-provisioned by the IdP instead (admins still come from Settings).
     from app.services.sso_provisioning import is_sso_only
@@ -310,10 +465,38 @@ 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:
-        return JSONResponse({"error": "Invalid credentials"}, status_code=401)
+        return JSONResponse({"error": MESSAGE_ECHEC_CONNEXION_LOCALE}, status_code=401)
 
     ud = dict(user)
     if not ud.get("is_active"):
@@ -332,7 +515,7 @@ def local_login(request: Request, body: dict = Body(default={})):
                 (attempts, lock, ud["id"]),
             )
             conn.commit()
-        return JSONResponse({"error": "Invalid credentials"}, status_code=401)
+        return JSONResponse({"error": MESSAGE_ECHEC_CONNEXION_LOCALE}, status_code=401)
 
     # Successful local login — SSO-only instances keep a way in for admins
     # only (every other account must use the IdP, design §7.1).

app/routers/dashboard/workspace.py

@@ -27,6 +27,22 @@ router = APIRouter(tags=["dashboard"])
 
 
 
+
+def _contexte_accueil() -> dict:
+    """Contexte de la page d'accueil publique (fusion #146).
+
+    Inscription fermée (défaut) : les boutons « Get started » de
+    l'accueil cèdent la place à un lien vers le Hub Dracodev, là où
+    les comptes se créent (URL dérivée de l'hôte, comme les autres
+    liens de la suite).
+    """
+    from app.services import draco_urls, reglages_acces
+
+    return {
+        "inscription_ouverte": reglages_acces.inscription_locale_ouverte(),
+        "hub_url": draco_urls.hub_url(),
+    }
+
 @router.get("/", response_class=HTMLResponse)
 async def dashboard(
     request: Request,
@@ -46,13 +62,13 @@ async def dashboard(
                     from app.templating import ENV
                     env = ENV
                     template = env.get_template("landing.html")
-                    return template.render()
+                    return template.render(**_contexte_accueil())
         except Exception:
             logger.exception("dashboard")
         from app.templating import ENV
         env = ENV
         template = env.get_template("landing.html")
-        return template.render()
+        return template.render(**_contexte_accueil())
 
     # ── Authenticated ──
     user_id = user.get("id", 1)

app/services/reglages_acces.py

@@ -0,0 +1,215 @@
+"""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
+les valeurs de ``app.config.settings`` (variables d'environnement /
+``.env``), elles-mêmes aux défauts du code.
+
+Réglage « inscription locale ouverte » :
+
+- **fermée par défaut** (décision de Bruno, programme « compte
+  partout ») : les comptes naissent dans le Hub Dracodev et entrent
+  dans Flowdeck par la voie ObsiGate (SSO) / le provisionnement JIT ;
+  le parcours public d'inscription locale est refusé proprement.
+- réversible à tout moment par un administrateur de l'instance
+  (``GET``/``PUT /api/admin/reglages-acces``) ou en posant
+  ``INSCRIPTION_LOCALE_OUVERTE=true`` avant tout enregistrement en
+  base.
+
+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
+
+logger = logging.getLogger(__name__)
+
+__all__ = [
+    "get_reglages_acces",
+    "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
+    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:
+    """Réglages d'accès effectifs — la ligne en base prime sur la config."""
+    reglages = {
+        # 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
+
+        with get_conn() as conn:
+            _assurer_table(conn)
+            row = conn.execute(
+                "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:
+        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,
+                       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,"
+            " 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["porte_centrale_active"] else 0),
+        )
+        conn.commit()
+    return actuels
+
+
+def inscription_locale_ouverte() -> bool:
+    """Vrai si l'inscription publique locale est ouverte sur l'instance."""
+    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).
+
+    Nomme le Hub Dracodev — là où les comptes se créent — avec son URL
+    dérivée de l'hôte comme les autres liens de la suite
+    (``draco_urls.hub_url()``, jamais un nom figé).
+    """
+    from app.services import draco_urls
+
+    return (
+        "L'inscription locale est fermée sur cette instance : "
+        "les comptes se créent dans le Hub Dracodev "
+        f"({draco_urls.hub_url()}), puis se connectent ici avec le "
+        "bouton « Login with ObsiGate (SSO) »."
+    )

app/templates/landing.html

@@ -179,7 +179,7 @@
   </a>
   <div class="landing-nav-actions">
     <a href="/auth/login?provider=local" class="btn btn-secondary">Log in</a>
-    <a href="/auth/register" class="btn btn-primary">Get started free</a>
+    {% if inscription_ouverte %}<a href="/auth/register" class="btn btn-primary">Get started free</a>{% else %}<a href="{{ hub_url }}" class="btn btn-primary">Créer un compte dans le Hub Dracodev</a>{% endif %}
   </div>
 </nav>
 
@@ -191,7 +191,7 @@
     All on your own server.
   </p>
   <div class="hero-actions">
-    <a href="/auth/register" class="btn btn-primary">Get started — it's free</a>
+    {% if inscription_ouverte %}<a href="/auth/register" class="btn btn-primary">Get started — it's free</a>{% else %}<a href="{{ hub_url }}" class="btn btn-primary">Créer un compte dans le Hub Dracodev</a>{% endif %}
     <a href="/auth/login?provider=local" class="btn btn-secondary">I already have an account</a>
   </div>
 </section>

tests/conftest.py

@@ -127,6 +127,14 @@ def client():
     from app.main import app
     init_db()
 
+    # Fusion #146 : l'inscription locale est fermée par défaut en
+    # production (les comptes naissent au Hub). L'environnement de
+    # test l'ouvre explicitement pour les suites historiques qui
+    # créent leurs comptes par /auth/register ; les tests du réglage
+    # (tests/test_reglages_acces.py) la ferment eux-mêmes.
+    from app.services import reglages_acces
+    reglages_acces.set_reglages_acces(inscription_locale_ouverte=True)
+
     yield login_test_client(TestClient(app))
 
     # Cleanup

tests/test_app.py

@@ -31,6 +31,12 @@ def client():
     from app.main import app
     init_db()
 
+    # Fusion #146 : inscription fermée par défaut en production —
+    # cette suite historique crée ses comptes par /auth/register,
+    # elle ouvre donc le réglage explicitement (comme conftest).
+    from app.services import reglages_acces
+    reglages_acces.set_reglages_acces(inscription_locale_ouverte=True)
+
     # A default user id=1 so tests that reference the implicit user (favorites,
     # workspace ownership) satisfy foreign keys without relying on leaked state.
     from app.db import get_conn

tests/test_porte_centrale.py

@@ -0,0 +1,222 @@
+"""FlowDeck — porte centrale unique (phase 2, programme « compte
+partout »), basée sur les réglages d'accès de la phase 1 (#146).
+
+Contrat :
+
+- réglage « porte centrale » **distinct** de celui d'inscription,
+  **désactivé par défaut** à la livraison ;
+- mode actif : l'écran de connexion ne présente que l'entrée
+  centrale (bouton ObsiGate SSO) et les identifiants locaux
+  ordinaires sont refusés — comptes historiques inclus ; les
+  sessions déjà établies ne sont pas touchées ;
+- **porte de secours** : UN compte administrateur local désigné,
+  identifiants posés par les variables d'environnement
+  ``FLOWDECK_SECOURS_ADMIN_LOGIN`` /
+  ``FLOWDECK_SECOURS_ADMIN_MOT_DE_PASSE``, authentification locale
+  uniquement par le chemin discret ``?secours=1`` (drapeau
+  ``secours`` à l'envoi) — jamais proposé sur l'écran principal ;
+- mode inactif : comportement actuel intégralement préservé.
+"""
+from __future__ import annotations
+
+import pytest
+from conftest import anon_csrf
+
+from app.services import reglages_acces
+
+LOGIN_SECOURS = "admin-secours"
+MDP_SECOURS = "mot-de-passe-de-secours-designe"
+
+
+def _activer():
+    reglages_acces.set_reglages_acces(porte_centrale_active=True)
+
+
+def _desactiver():
+    reglages_acces.set_reglages_acces(porte_centrale_active=False)
+
+
+def _creer_compte_local(login: str, mot_de_passe: str, admin: int = 0) -> None:
+    from app.db import get_conn
+    from app.password_utils import hash_password
+
+    with get_conn() as conn:
+        conn.execute(
+            "INSERT OR REPLACE INTO users (login, full_name, email,"
+            " password_hash, is_admin) VALUES (?, ?, ?, ?, ?)",
+            (login, login, f"{login}@test.dev",
+             hash_password(mot_de_passe), admin),
+        )
+        conn.commit()
+
+
+@pytest.fixture
+def secours_env(monkeypatch):
+    """Pose les variables d'environnement de la porte de secours."""
+    monkeypatch.setenv("FLOWDECK_SECOURS_ADMIN_LOGIN", LOGIN_SECOURS)
+    monkeypatch.setenv("FLOWDECK_SECOURS_ADMIN_MOT_DE_PASSE", MDP_SECOURS)
+    _creer_compte_local(LOGIN_SECOURS, "ancien-mot-de-passe-local", admin=1)
+    return monkeypatch
+
+
+# ── Défaut et distinction des réglages ──────────────────────────────
+
+def test_porte_centrale_desactivee_par_defaut_dans_le_code():
+    from app.config import settings
+
+    assert settings.porte_centrale_active is False
+
+
+def test_reglage_distinct_de_celui_d_inscription(client):
+    reglages_acces.set_reglages_acces(
+        inscription_locale_ouverte=True, porte_centrale_active=False)
+    reglages = reglages_acces.get_reglages_acces()
+    assert reglages["inscription_locale_ouverte"] is True
+    assert reglages["porte_centrale_active"] is False
+
+
+# ── Mode actif : le local ordinaire est refusé ──────────────────────
+
+def test_mode_actif_refuse_compte_ordinaire(client):
+    _creer_compte_local("ordinaire", "secret123")
+    _activer()
+    r = anon_csrf(client).post("/auth/local-login", json={
+        "email": "ordinaire", "password": "secret123"})
+    assert r.status_code == 403
+    assert "ObsiGate (SSO)" in r.json()["error"]
+
+
+def test_mode_actif_refuse_compte_local_historique(client):
+    """Compte créé par inscription publique (quand elle était
+    ouverte), puis porte activée : son mot de passe local ne passe
+    plus."""
+    reglages_acces.set_reglages_acces(
+        inscription_locale_ouverte=True, porte_centrale_active=False)
+    r = client.post("/auth/register", json={
+        "email": "[email protected]", "password": "secret123",
+        "name": "Historique"})
+    assert r.status_code == 200
+    _activer()
+    r = anon_csrf(client).post("/auth/local-login", json={
+        "email": "[email protected]", "password": "secret123"})
+    assert r.status_code == 403
+
+
+def test_mode_actif_ecran_connexion_que_l_entree_centrale(client):
+    _activer()
+    r = anon_csrf(client).get("/auth/login?provider=local")
+    assert r.status_code == 200
+    # L'entrée centrale, bien visible…
+    assert "Login with ObsiGate (SSO)" in r.text
+    # … et rien d'autre : ni formulaire local, ni onglet Register,
+    # ni lien vers le chemin discret de secours.
+    assert 'id="login-form"' not in r.text
+    assert 'id="password"' not in r.text
+    assert 'id="tab-register"' not in r.text
+    assert "secours" not in r.text
+
+
+def test_mode_actif_inscription_aussi_fermee(client):
+    reglages_acces.set_reglages_acces(inscription_locale_ouverte=True)
+    _activer()
+    r = client.post("/auth/register", json={
+        "email": "[email protected]", "password": "secret123"})
+    assert r.status_code == 403
+
+
+def test_mode_actif_session_deja_etablie_non_touchee(client):
+    _creer_compte_local("deja-dedans", "secret123")
+    c = anon_csrf(client)
+    r = c.post("/auth/local-login", json={
+        "email": "deja-dedans", "password": "secret123"})
+    assert r.status_code == 200
+    _activer()
+    r = c.get("/auth/user")
+    assert r.json()["authenticated"] is True
+
+
+# ── Porte de secours administrateur ─────────────────────────────────
+
+def test_secours_connexion_admin_par_le_chemin_discret(client, secours_env):
+    _activer()
+    # L'écran discret rend le formulaire, marqué « secours ».
+    r = anon_csrf(client).get("/auth/login?provider=local&secours=1")
+    assert r.status_code == 200
+    assert 'id="login-form"' in r.text
+    assert "secours:true" in r.text
+    # L'authentification elle-même : identifiants d'environnement.
+    r = anon_csrf(client).post("/auth/local-login", json={
+        "email": LOGIN_SECOURS, "password": MDP_SECOURS,
+        "secours": True})
+    assert r.status_code == 200
+    assert r.json()["status"] == "ok"
+    assert "flowdeck_session" in r.headers.get("set-cookie", "")
+
+
+def test_secours_mauvais_mot_de_passe_environnement_refuse(client, secours_env):
+    _activer()
+    r = anon_csrf(client).post("/auth/local-login", json={
+        "email": LOGIN_SECOURS, "password": "pas-le-bon",
+        "secours": True})
+    assert r.status_code == 401
+
+
+def test_secours_sans_drapeau_refuse_meme_pour_l_admin(client, secours_env):
+    """Sans le drapeau du chemin discret, même les identifiants de
+    secours sont traités comme un envoi ordinaire : refusés."""
+    _activer()
+    r = anon_csrf(client).post("/auth/local-login", json={
+        "email": LOGIN_SECOURS, "password": MDP_SECOURS})
+    assert r.status_code == 403
+
+
+def test_secours_compte_non_admin_refuse(client, secours_env, monkeypatch):
+    """Le compte désigné doit être administrateur : un compte
+    ordinaire désigné par les variables ne passe pas."""
+    _creer_compte_local("pas-admin", "secret123", admin=0)
+    monkeypatch.setenv("FLOWDECK_SECOURS_ADMIN_LOGIN", "pas-admin")
+    monkeypatch.setenv("FLOWDECK_SECOURS_ADMIN_MOT_DE_PASSE", "secret123")
+    _activer()
+    r = anon_csrf(client).post("/auth/local-login", json={
+        "email": "pas-admin", "password": "secret123", "secours": True})
+    assert r.status_code == 401
+
+
+def test_secours_sans_variables_environnement_fermee(client, monkeypatch):
+    monkeypatch.delenv("FLOWDECK_SECOURS_ADMIN_LOGIN", raising=False)
+    monkeypatch.delenv("FLOWDECK_SECOURS_ADMIN_MOT_DE_PASSE", raising=False)
+    _creer_compte_local("admin-local", "secret123", admin=1)
+    _activer()
+    r = anon_csrf(client).post("/auth/local-login", json={
+        "email": "admin-local", "password": "secret123", "secours": True})
+    assert r.status_code == 401
+
+
+# ── Mode inactif : comportement actuel intégralement préservé ───────
+
+def test_mode_inactif_connexion_locale_comme_avant(client):
+    _desactiver()
+    _creer_compte_local("normal", "secret123")
+    r = anon_csrf(client).post("/auth/local-login", json={
+        "email": "normal", "password": "secret123"})
+    assert r.status_code == 200
+    assert r.json()["status"] == "ok"
+
+
+def test_mode_inactif_ecran_connexion_complet(client):
+    _desactiver()
+    r = anon_csrf(client).get("/auth/login?provider=local")
+    assert r.status_code == 200
+    assert 'id="login-form"' in r.text
+    assert "Login with ObsiGate (SSO)" in r.text
+
+
+def test_api_admin_aller_retour_porte_centrale(client):
+    _desactiver()
+    r = client.put("/api/admin/reglages-acces",
+                   json={"porte_centrale_active": True})
+    assert r.status_code == 200
+    assert r.json()["porte_centrale_active"] is True
+    r = client.get("/api/admin/reglages-acces")
+    assert r.json()["porte_centrale_active"] is True
+    _desactiver()

tests/test_reglages_acces.py

@@ -0,0 +1,177 @@
+"""FlowDeck — réglages d'accès : inscription locale (fusion #146, #144).
+
+Contrat de la phase 1 du programme « compte partout » :
+
+- inscription locale **fermée par défaut** (décision de Bruno) :
+  le parcours public d'inscription est refusé proprement et nomme
+  le Hub Dracodev, là où les comptes se créent ;
+- réglage **réversible par un administrateur** (API
+  ``/api/admin/reglages-acces``) : ouverte, l'inscription redevient
+  exactement celle d'aujourd'hui ;
+- la connexion des comptes existants (locaux et draco) n'est
+  **jamais** affectée par le réglage ;
+- #144 : l'échec du formulaire de connexion locale suggère la voie
+  ObsiGate (SSO).
+
+Le harnais de test ouvre l'inscription pour les suites historiques
+(voir conftest) ; chaque test pose donc explicitement l'état qu'il
+vérifie via le service des réglages.
+"""
+from __future__ import annotations
+
+from conftest import anon_csrf
+
+from app.services import reglages_acces
+
+
+def _fermer():
+    reglages_acces.set_reglages_acces(inscription_locale_ouverte=False)
+
+
+def _ouvrir():
+    reglages_acces.set_reglages_acces(inscription_locale_ouverte=True)
+
+
+def _creer_compte_local(login: str, mot_de_passe: str, admin: int = 0) -> None:
+    from app.db import get_conn
+    from app.password_utils import hash_password
+
+    with get_conn() as conn:
+        conn.execute(
+            "INSERT OR REPLACE INTO users (login, full_name, email,"
+            " password_hash, is_admin) VALUES (?, ?, ?, ?, ?)",
+            (login, login, f"{login}@test.dev",
+             hash_password(mot_de_passe), admin),
+        )
+        conn.commit()
+
+
+# ── Réglage fermé : inscription impossible + message ────────────────
+
+def test_inscription_fermee_par_defaut_dans_le_code():
+    """Le défaut du code (hors toute ligne en base) est « fermée »."""
+    from app.config import settings
+
+    assert settings.inscription_locale_ouverte is False
+
+
+def test_inscription_fermee_post_refuse_avec_message_hub(client):
+    _fermer()
+    r = client.post("/auth/register", json={
+        "email": "[email protected]", "password": "secret123",
+        "name": "Visiteur"})
+    assert r.status_code == 403
+    erreur = r.json()["error"]
+    assert "Hub Dracodev" in erreur
+    # Lien dérivé vers le Hub fourni à l'écran comme aux API.
+    assert r.json()["hub_url"]
+    # Aucun compte n'a été créé.
+    from app.db import get_conn
+    with get_conn() as conn:
+        assert conn.execute(
+            "SELECT COUNT(*) FROM users WHERE login='[email protected]'"
+        ).fetchone()[0] == 0
+
+
+def test_inscription_fermee_page_refus_propre(client):
+    _fermer()
+    r = anon_csrf(client).get("/auth/register", follow_redirects=False)
+    assert r.status_code == 403
+    assert "Hub Dracodev" in r.text
+    assert "les comptes se créent" in r.text
+
+
+def test_inscription_fermee_page_connexion_sans_onglet_register(client):
+    _fermer()
+    r = anon_csrf(client).get("/auth/login?provider=local")
+    assert r.status_code == 200
+    assert 'id="tab-register"' not in r.text
+    # L'avis nomme le Hub et la voie SSO reste visible.
+    assert "Hub Dracodev" in r.text
+    assert "Login with ObsiGate (SSO)" in r.text
+
+
+# ── Réglage ouvert : inscription comme aujourd'hui ──────────────────
+
+def test_inscription_ouverte_post_comme_avant(client):
+    _ouvrir()
+    r = client.post("/auth/register", json={
+        "email": "[email protected]", "password": "secret123",
+        "name": "Nouveau"})
+    assert r.status_code == 200
+    assert r.json()["status"] == "ok"
+
+
+def test_inscription_ouverte_page_register_affichee(client):
+    _ouvrir()
+    r = anon_csrf(client).get("/auth/register", follow_redirects=False)
+    assert r.status_code == 200
+    assert 'id="tab-register"' in r.text
+
+
+# ── Connexion des comptes existants : jamais affectée ───────────────
+
+def test_connexion_compte_local_existant_inscription_fermee(client):
+    _creer_compte_local("ancien", "secret123")
+    _fermer()
+    r = anon_csrf(client).post("/auth/local-login", json={
+        "email": "ancien", "password": "secret123"})
+    assert r.status_code == 200
+    assert r.json()["status"] == "ok"
+
+
+def test_connexion_compte_draco_sans_mot_de_passe_inchangee(client):
+    """Un compte draco (sans mot de passe local) reste refusé en local
+    de la même façon, réglage ouvert ou fermé : le réglage ne change
+    rien à l'authentification."""
+    from app.db import get_conn
+    with get_conn() as conn:
+        conn.execute(
+            "INSERT OR REPLACE INTO users (login, full_name, email,"
+            " password_hash, auth_method) VALUES"
+            " ('draco-42', 'Dan Test', '[email protected]', NULL, 'draco')")
+        conn.commit()
+    for ouvrir in (True, False):
+        reglages_acces.set_reglages_acces(
+            inscription_locale_ouverte=ouvrir)
+        r = anon_csrf(client).post("/auth/local-login", json={
+            "email": "draco-42", "password": "nimporte"})
+        assert r.status_code == 401
+
+
+# ── #144 : l'échec local suggère la voie ObsiGate (SSO) ─────────────
+
+def test_echec_connexion_locale_suggere_sso(client):
+    _creer_compte_local("quelquun", "secret123")
+    r = anon_csrf(client).post("/auth/local-login", json={
+        "email": "quelquun", "password": "mauvais-mot-de-passe"})
+    assert r.status_code == 401
+    assert "ObsiGate (SSO)" in r.json()["error"]
+    assert "Hub Dracodev" in r.json()["error"]
+
+
+def test_echec_connexion_compte_inconnu_suggere_sso(client):
+    r = anon_csrf(client).post("/auth/local-login", json={
+        "email": "[email protected]", "password": "nimporte"})
+    assert r.status_code == 401
+    assert "ObsiGate (SSO)" in r.json()["error"]
+
+
+# ── Administration du réglage ────────────────────────────────────────
+
+def test_api_admin_reglages_acces_aller_retour(client):
+    """Le client de test est administrateur : lecture + écriture."""
+    _fermer()
+    r = client.get("/api/admin/reglages-acces")
+    assert r.status_code == 200
+    assert r.json()["inscription_locale_ouverte"] is False
+    r = client.put("/api/admin/reglages-acces",
+                   json={"inscription_locale_ouverte": True})
+    assert r.status_code == 200
+    assert r.json()["inscription_locale_ouverte"] is True
+    assert reglages_acces.inscription_locale_ouverte() is True
+
+
+def test_api_admin_reglages_acces_refusee_aux_anonymes(client):
+    r = anon_csrf(client).get("/api/admin/reglages-acces")
+    assert r.status_code in (401, 403)

tests/test_v66_agent_api.py

@@ -42,6 +42,11 @@ def client():
     settings.agent_run_timeout_seconds = 30
 
     init_db()
+    # Fusion #146 : inscription fermée par défaut en production —
+    # _token() crée ses comptes par /auth/register, la suite ouvre
+    # donc le réglage explicitement (comme conftest).
+    from app.services import reglages_acces
+    reglages_acces.set_reglages_acces(inscription_locale_ouverte=True)
     with get_conn() as conn:
         conn.execute(
             "INSERT OR IGNORE INTO users (login, full_name, email, password_hash, is_admin) "