@nosserb/prmt 0.0.0-stage → 2.0.0

package/tui/promethee/ollama.py

@@ -0,0 +1,52 @@
+"""Client HTTP d'Ollama (API locale)."""
+from __future__ import annotations
+
+import json
+import os
+import urllib.error
+import urllib.request
+
+# --------------------------------------------------------------------------- Ollama
+def ollama_url() -> str:
+    host = os.environ.get("OLLAMA_HOST", "").strip() or "127.0.0.1:11434"
+    if "://" not in host:
+        host = "http://" + host
+    host = host.replace("0.0.0.0", "127.0.0.1").rstrip("/")
+    if host.count(":") == 1:  # pas de port précisé
+        host += ":11434"
+    return host
+
+
+OLLAMA = ollama_url()
+
+
+def api(path: str, payload: dict | None = None, timeout: float = 30, on_open=None) -> dict:
+    """Appel à l'API d'Ollama. on_open reçoit la réponse dès qu'elle est ouverte : la fermer depuis un autre fil
+    interrompt la lecture (Esc pendant un appel long)."""
+    data = json.dumps(payload).encode("utf-8") if payload is not None else None
+    req = urllib.request.Request(
+        OLLAMA + path,
+        data=data,
+        headers={"Content-Type": "application/json"},
+        method="POST" if data is not None else "GET",
+    )
+    with urllib.request.urlopen(req, timeout=timeout) as resp:
+        if on_open is not None:
+            on_open(resp)
+        return json.loads(resp.read().decode("utf-8"))
+
+
+def context_from_env(default: int = 4096) -> int:
+    """Taille de contexte par défaut d'Ollama (OLLAMA_CONTEXT_LENGTH), si le modèle n'en fixe pas."""
+    try:
+        value = int(os.environ.get("OLLAMA_CONTEXT_LENGTH") or default)
+    except ValueError:
+        return default
+    return value if value > 0 else default
+
+
+def http_error_text(err: urllib.error.HTTPError) -> str:
+    try:
+        return json.loads(err.read().decode("utf-8")).get("error", str(err))
+    except Exception:
+        return str(err)

package/tui/promethee/plan.py

@@ -0,0 +1,91 @@
+"""Mode plan, liste de tâches et étapes de la méthode d'audit."""
+from __future__ import annotations
+
+import re
+import subprocess
+from pathlib import Path
+
+from .config import CREATE_NO_WINDOW
+from .shell import decode_output, refreshed_env
+
+# --------------------------------------------------------------------------- Mode plan et liste de tâches
+# Format mesuré : titres courts (bons pour la liste de tâches), commandes réelles, plus de « executer_commande »
+# ni de script .bat écrits en texte (que le modèle imitait ensuite au lieu d'appeler l'outil).
+PLAN_REMINDER = ("\n\n(Mode plan, activé par l'utilisateur : n'exécute rien maintenant. Réponds UNIQUEMENT par un plan "
+                 "numéroté de 2 à 6 étapes, avec seulement ce qui est nécessaire pour ma demande (pas d'étape en plus, "
+                 "comme enregistrer les résultats dans un fichier si je ne l'ai pas demandé), une par ligne, au format : "
+                 "`N. Titre court : action`. Le titre fait 2 à 5 "
+                 "mots. L'action est UNE commande PowerShell simple qui existe vraiment, entre backticks, ou le fichier "
+                 "à créer ou modifier (pas de nom d'outil). La dernière étape est le bilan, sans commande. Termine par : "
+                 "« Je l'exécute ? »)")
+# Mesuré : sans cette phrase, « quelle est l'IP de ma VM Kali ? » lançait ipconfig (3/3) au lieu de lire la mémoire ;
+# avec elle : réponse depuis la mémoire 3/3, et « quelle est mon adresse IP ? » lance toujours ipconfig (3/3).
+MEMORY_HINT = " Si l'information demandée est déjà dans ta mémoire (PROMETHEE.md), réponds directement avec elle, sans commande."
+PLAN_APPROVED = ("J'approuve ton plan. Exécute-le maintenant, étape par étape, avec les outils "
+                 "(une commande à la fois), puis fais le bilan.")
+PLAN_STEP = re.compile(r"^\s*(\d{1,2})[.)]\s+(.+)$")
+
+
+def plan_steps(text: str, limit: int = 10) -> list[tuple[str, str, bool]]:
+    """Étapes numérotées d'un plan : (titre court, texte complet, contient une commande ou un fichier)."""
+    steps = []
+    for line in text.split("\n"):
+        match = PLAN_STEP.match(line)
+        if not match or match.group(2).strip().endswith("?"):  # « 6. Je l'exécute ? » n'est pas une étape
+            continue
+        full = re.sub(r"[*_`]", "", match.group(2)).strip()
+        title = re.split(r"\s+:\s+|\s+[-–—]\s+|:\s", full, maxsplit=1)[0].strip().rstrip(":")
+        if len(title) > 60:
+            title = title[:58].rsplit(" ", 1)[0] + "…"
+        steps.append((title or full[:60], full, "`" in match.group(2)))
+    return steps[:limit]
+
+
+# Le petit modèle invente des cmdlets dans ses plans (« Get-OpenPort ») : on les repère avant de montrer le plan.
+PLAN_CODE = re.compile(r"`([^`\n]+)`")
+PLAN_CMDLET = re.compile(r"(?:^|[|;({])\s*([A-Za-z]{2,}-[A-Za-z]{2,})(?![\w-])")
+PLAN_FIX = ("(Contrôle automatique du plan : {names} n'existe pas sur ce PC, c'est une commande inventée. Réécris le "
+            "plan complet, au même format, en remplaçant chaque commande inventée par une vraie commande PowerShell. "
+            "Termine par : « Je l'exécute ? »)")
+
+
+def missing_cmdlets(text: str, cwd: Path) -> list[str]:
+    """Cmdlets (Verbe-Nom) en tête des commandes d'un plan qui n'existent pas sur cette machine."""
+    names: list[str] = []
+    for line in text.split("\n"):
+        if PLAN_STEP.match(line):
+            for code in PLAN_CODE.findall(line):
+                for name in PLAN_CMDLET.findall(code.strip()):
+                    if name.lower() not in (n.lower() for n in names):
+                        names.append(name)
+    if not names:
+        return []
+    script = ("foreach ($n in @(" + ",".join(f"'{n}'" for n in names) + ")) "
+              "{ if (-not (Get-Command $n -ErrorAction SilentlyContinue)) { $n } }")
+    try:
+        proc = subprocess.run(["powershell.exe", "-NoProfile", "-NonInteractive", "-Command", script],
+                              cwd=str(cwd), env=refreshed_env(), stdin=subprocess.DEVNULL, capture_output=True,
+                              creationflags=CREATE_NO_WINDOW, timeout=20)
+    except (OSError, subprocess.SubprocessError):
+        return []  # la vérification ne doit jamais bloquer l'utilisateur
+    found = {line.strip().lower() for line in decode_output(proc.stdout).split("\n") if line.strip()}
+    return [n for n in names if n.lower() in found]
+
+
+# Étapes de la méthode d'audit, cochées d'après les commandes réellement exécutées (pas d'après le modèle)
+AUDIT_TASKS = [
+    ("Résolution DNS", r"Resolve-DnsName|nslookup|\bdig\b"),
+    ("Ports et services (nmap)", r"\bnmap\b(?!.*ssl-enum)"),
+    ("En-têtes HTTP", r"curl(?:\.exe)?\b.*\s-\w*I|Invoke-WebRequest|\biwr\b|-Method\s+Head"),
+    ("Configuration TLS", r"ssl-enum-ciphers|testssl|openssl\s+s_client|sslscan"),
+    ("robots.txt", r"robots\.txt"),
+    ("Rapport final", None),
+]
+
+
+def command_keywords(command: str) -> list[str]:
+    """Mots qui identifient une commande (programme, fichiers) pour la rattacher à une étape du plan."""
+    first = re.split(r"[\s|;]", command.strip().strip("&'\" "), maxsplit=1)[0]
+    words = [Path(first.strip("'\"")).name.lower().removesuffix(".exe")]
+    words += [w.lower() for w in re.findall(r"[\w.-]+\.[A-Za-z]\w{0,4}", command)]
+    return [w for w in dict.fromkeys(words) if len(w) >= 3]

package/tui/promethee/politique.py

@@ -0,0 +1,429 @@
+"""Politique d'exécution : liste blanche, périmètre et verdicts, partagés avec la console web.
+
+La TUI ne décide pas seule si une commande est autorisée. Elle le demande au moteur de la console
+(TypeScript), par un petit programme, le « pont », qu'elle lance et à qui elle parle en JSON, une
+demande par ligne. Le pont analyse la commande avec le vrai analyseur de PowerShell et rend un verdict.
+Il n'exécute jamais rien.
+
+Deux modes :
+- stricte (par défaut) : tout refus de la liste blanche est appliqué, comme dans la console ;
+- souple : ce que l'analyse ne sait pas vérifier (scripts, compilateurs, programmes lancés par leur
+  chemin) t'est montré comme « hors politique » et tu le valides toi-même. Les planchers refusent
+  dans les deux modes : commande destructrice non débloquée, cible hors périmètre, protections de
+  Windows, chemin réseau.
+
+Si le pont n'est pas disponible (console absente, Node introuvable), verdict() renvoie None : la TUI
+retombe sur sa validation manuelle, commande par commande, et l'affiche dans la barre d'état.
+"""
+from __future__ import annotations
+
+import json
+import os
+import queue
+import shutil
+import subprocess
+import threading
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from .config import CREATE_NO_WINDOW, SAVE_DIR
+from .shell import refreshed_env
+
+MODES = ("stricte", "souple")
+RENDEZ_VOUS = SAVE_DIR / "plateforme.json"
+DELAI_DEMARRAGE = 25.0     # secondes : Node puis l'analyseur PowerShell du pont
+DELAI_DEMANDE = 20.0
+ATTENTE_APRES_ECHEC = 30.0  # avant de retenter un pont qui n'a pas démarré
+_AUTO = object()
+
+
+class Indisponible(Exception):
+    """Le pont ne répond pas (absent, arrêté, délai dépassé)."""
+
+
+class Refus(Exception):
+    """Le pont a répondu par une erreur (demande invalide, cible inconnue…)."""
+
+    def __init__(self, code: str, message: str) -> None:
+        super().__init__(message)
+        self.code = code
+
+
+# --------------------------------------------------------------------------- verdict
+@dataclass(frozen=True)
+class Raison:
+    code: str
+    message: str
+    gravite: str = "block"        # block · warn · info
+    plancher: bool = False        # refus qui tient aussi en politique souple
+    sujet: str | None = None      # ce qu'il faudrait autoriser : nom de commande, ou hôte
+
+
+@dataclass(frozen=True)
+class Verdict:
+    issue: str                    # read · sensitive · outside (hors politique, à valider) · refused
+    niveau: str = "read"          # niveau brut de la liste blanche : read · sensitive · denied
+    mode: str = "stricte"
+    raisons: tuple[Raison, ...] = ()
+    blocages: tuple[Raison, ...] = ()
+    ecritures: tuple[str, ...] = ()
+    reseau: tuple[str, ...] = ()
+    cd: str | None = None
+    commandes: tuple[str, ...] = field(default=())
+    modules: tuple[str, ...] = ()   # modules de fonctions à charger avant le mode contraint (NetTCPIP, NetSecurity…)
+    contraint: bool = False         # réglage de la console : exécuter en mode de langage contraint
+
+    @property
+    def refusee(self) -> bool:
+        return self.issue == "refused"
+
+    @property
+    def lecture(self) -> bool:
+        return self.issue == "read"
+
+    @property
+    def mode_contraint(self) -> bool:
+        """La commande s'exécute en mode de langage contraint : PowerShell bloque alors lui-même les appels .NET
+        arbitraires, même si la politique était contournée. Vaut pour ce que la liste blanche a autorisé ; une
+        commande hors politique, que tu valides seul, garde le langage complet (un script en a souvent besoin)."""
+        return self.contraint and self.issue in ("read", "sensitive")
+
+    @property
+    def codes(self) -> list[str]:
+        return [r.code for r in (self.blocages if self.refusee else self.raisons)]
+
+    def a_lire(self) -> list[Raison]:
+        """Ce qu'il faut lire avant de valider : avertissements, et refus de la liste blanche levés par le mode souple."""
+        return [r for r in self.raisons if r.gravite in ("warn", "block")]
+
+    def conseils(self) -> list[str]:
+        """Commandes de la TUI qui lèveraient le refus (aucune pour un plancher qui ne se lève pas)."""
+        out: list[str] = []
+        for r in self.blocages:
+            if r.code in ("destructive", "not-allowlisted") and r.sujet:
+                out.append(f"/permissions autoriser {r.sujet}")
+            elif r.code == "target-out-of-scope" and r.sujet:
+                out.append(f"/perimetre ajouter {r.sujet}")
+            elif not r.plancher and r.code not in ("not-found", "not-allowlisted") and self.mode == "stricte":
+                out.append("/politique souple")
+        return list(dict.fromkeys(out))
+
+    def resume(self) -> str:
+        """Une ligne pour l'écran : la première raison du refus."""
+        if not self.blocages:
+            return ""
+        first = self.blocages[0].message
+        return first + (f" (+{len(self.blocages) - 1})" if len(self.blocages) > 1 else "")
+
+    def pour_modele(self) -> str:
+        """Ce que le modèle reçoit à la place du résultat d'une commande refusée."""
+        reasons = " ; ".join(r.message for r in self.blocages) or "commande non autorisée"
+        text = ("Non exécutée : la politique de sécurité de Prométhée refuse cette commande (elle n'a pas été montrée à "
+                f"l'utilisateur). Raisons : {reasons}")
+        advice = self.conseils()
+        if advice:
+            text += (" L'utilisateur peut lever ce refus lui-même en tapant : " + " ou ".join(f"`{a}`" for a in advice)
+                     + ". Dis-le-lui en une phrase.")
+        return text + (" Ne contourne pas ce refus par une autre commande qui ferait la même chose. Si une commande de "
+                       "lecture répond à la demande, utilise-la ; sinon explique le refus et arrête-toi.")
+
+    @classmethod
+    def depuis(cls, data: dict) -> "Verdict":
+        def raison(r: dict) -> Raison:
+            return Raison(code=str(r.get("code") or "?"), message=str(r.get("plain") or r.get("message") or ""),
+                          gravite=str(r.get("severity") or "block"), plancher=r.get("floor") is True,
+                          sujet=r.get("subject") if isinstance(r.get("subject"), str) else None)
+
+        issue = data.get("outcome")
+        if issue not in ("read", "sensitive", "outside", "refused"):
+            raise Indisponible(f"verdict illisible (issue : {issue!r})")
+        return cls(
+            issue=issue, niveau=str(data.get("level") or "denied"), mode=str(data.get("mode") or "stricte"),
+            raisons=tuple(raison(r) for r in data.get("reasons") or [] if isinstance(r, dict)),
+            blocages=tuple(raison(r) for r in data.get("blocking") or [] if isinstance(r, dict)),
+            ecritures=tuple(str(w) for w in data.get("writes") or []),
+            reseau=tuple(str(h) for h in data.get("network") or []),
+            cd=data.get("cd") if isinstance(data.get("cd"), str) else None,
+            commandes=tuple(str(c.get("resolved") or c.get("name") or "") for c in data.get("commands") or [] if isinstance(c, dict)),
+            modules=tuple(str(m) for m in data.get("modules") or []),
+            contraint=data.get("constrained") is True,
+        )
+
+
+# --------------------------------------------------------------------------- rendez-vous
+def rendez_vous(fichier: Path | None = None) -> tuple[dict | None, str]:
+    """Où trouver le pont. Renvoie (lien, raison si absent).
+
+    PROMETHEE_PLATEFORME : « aucune » (pas de politique partagée), ou le dossier de la console.
+    Sinon, le fichier plateforme.json que la console écrit dans Documents\\Promethee à son démarrage.
+    """
+    forced = os.environ.get("PROMETHEE_PLATEFORME", "").strip()
+    if forced.lower() in ("aucune", "none", "0", "non"):
+        return None, "désactivée (PROMETHEE_PLATEFORME=aucune)"
+    if forced:
+        root = Path(forced)
+        lien = {"node": shutil.which("node") or "", "pont": str(root / "server" / "cli" / "pont.ts"),
+                "donnees": os.environ.get("PROMETHEE_DATA") or str(root / "data"), "racine": str(root), "port": 4317}
+    else:
+        try:
+            lien = json.loads((fichier or RENDEZ_VOUS).read_text(encoding="utf-8"))
+        except OSError:
+            return None, "console non reliée : lance « npm run lier » dans le dossier de la console"
+        except ValueError:
+            return None, f"fichier de liaison illisible ({fichier or RENDEZ_VOUS})"
+        if not isinstance(lien, dict):
+            return None, f"fichier de liaison illisible ({fichier or RENDEZ_VOUS})"
+    node, pont = str(lien.get("node") or ""), str(lien.get("pont") or "")
+    if not node or not (Path(node).is_file() or shutil.which(node)):
+        return None, "Node est introuvable : la console a besoin de Node pour rendre ses verdicts"
+    if not Path(pont).is_file():
+        return None, f"le pont de la console est introuvable ({pont}) : relance « npm run lier » dans son dossier"
+    if not isinstance(lien.get("donnees"), str) or not lien["donnees"]:
+        return None, "fichier de liaison incomplet (dossier des données)"
+    return lien, ""
+
+
+# --------------------------------------------------------------------------- pont (processus Node)
+class Pont:
+    """Le processus du pont : une demande par ligne sur son entrée, une réponse par ligne sur sa sortie."""
+
+    def __init__(self, lien: dict, env: dict[str, str]) -> None:
+        self.lien = lien
+        self.env = {**env, "PROMETHEE_DATA": str(lien["donnees"])}
+        self.version = ""
+        self._proc: subprocess.Popen | None = None
+        self._attentes: dict[int, queue.Queue] = {}
+        self._verrou = threading.Lock()
+        self._pret = threading.Event()
+        self._numero = 0
+        self._erreurs: list[str] = []
+
+    @property
+    def vivant(self) -> bool:
+        return self._proc is not None and self._proc.poll() is None
+
+    def demarrer(self, delai: float = DELAI_DEMARRAGE) -> None:
+        try:
+            self._proc = subprocess.Popen(
+                [str(self.lien["node"]), str(self.lien["pont"])], env=self.env, stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE, stderr=subprocess.PIPE, creationflags=CREATE_NO_WINDOW,
+                cwd=str(Path(str(self.lien["pont"])).parent),
+            )
+        except OSError as err:
+            raise Indisponible(f"le pont n'a pas pu être lancé ({err})") from err
+        if self._proc.stdin is None or self._proc.stdout is None:
+            raise Indisponible("le pont n'a pas pu être lancé")
+        threading.Thread(target=self._lire, daemon=True).start()
+        threading.Thread(target=self._lire_erreurs, daemon=True).start()
+        if not self._pret.wait(delai):
+            detail = self.erreur()
+            self.fermer()
+            raise Indisponible("le pont n'a pas démarré" + (f" : {detail}" if detail else f" en {delai:.0f} s"))
+
+    def erreur(self) -> str:
+        """Dernière ligne utile écrite par le pont sur sa sortie d'erreur."""
+        lines = [l for l in self._erreurs if l.strip() and "ExperimentalWarning" not in l and "--trace-warnings" not in l]
+        return lines[-1].strip()[:300] if lines else ""
+
+    def _lire(self) -> None:
+        proc = self._proc
+        try:
+            for raw in proc.stdout:
+                try:
+                    message = json.loads(raw.decode("utf-8"))
+                except ValueError:
+                    continue
+                if not isinstance(message, dict):
+                    continue
+                if message.get("ready"):
+                    self.version = str(message.get("version") or "")
+                    self._pret.set()
+                    continue
+                with self._verrou:
+                    attente = self._attentes.pop(message.get("id"), None)
+                if attente is not None:
+                    attente.put(message)
+        except (OSError, ValueError):
+            pass
+        # Le pont s'est arrêté : on libère ceux qui attendaient encore une réponse
+        with self._verrou:
+            attentes, self._attentes = list(self._attentes.values()), {}
+        for attente in attentes:
+            attente.put(None)
+
+    def _lire_erreurs(self) -> None:
+        proc = self._proc
+        try:
+            for raw in proc.stderr:
+                self._erreurs.append(raw.decode("utf-8", "replace"))
+                del self._erreurs[:-20]
+        except (OSError, ValueError):
+            pass
+
+    def demander(self, op: str, delai: float = DELAI_DEMANDE, **champs) -> dict:
+        if not self.vivant:
+            raise Indisponible("le pont est arrêté" + (f" : {self.erreur()}" if self.erreur() else ""))
+        attente: queue.Queue = queue.Queue(maxsize=1)
+        with self._verrou:
+            self._numero += 1
+            numero = self._numero
+            self._attentes[numero] = attente
+            try:
+                self._proc.stdin.write((json.dumps({"id": numero, "op": op, **champs}, ensure_ascii=False) + "\n").encode("utf-8"))
+                self._proc.stdin.flush()
+            except (OSError, ValueError) as err:
+                self._attentes.pop(numero, None)
+                raise Indisponible(f"le pont ne reçoit plus les demandes ({err})") from err
+        try:
+            reponse = attente.get(timeout=delai)
+        except queue.Empty:
+            with self._verrou:
+                self._attentes.pop(numero, None)
+            raise Indisponible(f"le pont n'a pas répondu en {delai:.0f} s") from None
+        if reponse is None:
+            raise Indisponible("le pont s'est arrêté pendant la demande" + (f" : {self.erreur()}" if self.erreur() else ""))
+        if not reponse.get("ok"):
+            error = reponse.get("error") or {}
+            raise Refus(str(error.get("code") or "erreur"), str(error.get("message") or "demande refusée par le pont"))
+        result = reponse.get("result")
+        return result if isinstance(result, dict) else {}
+
+    def fermer(self) -> None:
+        proc, self._proc = self._proc, None
+        if proc is None:
+            return
+        try:
+            if proc.stdin:
+                proc.stdin.close()   # fin de l'entrée : le pont s'arrête de lui-même
+            proc.wait(timeout=2)
+        except (OSError, ValueError, subprocess.TimeoutExpired):
+            try:
+                proc.kill()
+            except OSError:
+                pass
+
+
+# --------------------------------------------------------------------------- service utilisé par l'application
+class Politique:
+    """Ce que l'application demande à la politique : un verdict, la liste blanche, le périmètre."""
+
+    def __init__(self, mode: str = "stricte", lien=_AUTO, environnement=refreshed_env) -> None:
+        self.mode = mode if mode in MODES else "stricte"
+        if lien is _AUTO:
+            self.lien, self.raison = rendez_vous()
+        else:
+            self.lien, self.raison = lien, "" if lien else "aucune console reliée"
+        self._environnement = environnement
+        self._pont: Pont | None = None
+        self._verrou = threading.Lock()
+        self._retenter_a = 0.0
+        self._path = ""
+        self.version = ""
+
+    # ---- état
+    @property
+    def reliee(self) -> bool:
+        return self.lien is not None
+
+    @property
+    def prete(self) -> bool:
+        return self._pont is not None and self._pont.vivant
+
+    @property
+    def etat(self) -> str:
+        """« prête », « non reliée », « indisponible » ou « en attente » (pas encore démarrée)."""
+        if not self.reliee:
+            return "non reliée"
+        if self.prete:
+            return "prête"
+        return "indisponible" if self.raison else "en attente"
+
+    def libelle(self) -> str:
+        """Texte court pour la barre d'état."""
+        if self.prete or self.etat == "en attente":
+            return f"politique {self.mode}"
+        return "validation manuelle"
+
+    # ---- pont
+    def _pont_pret(self) -> Pont:
+        """Le pont, démarré au besoin. Relancé si le PATH a changé (logiciel installé pendant la session)."""
+        if self.lien is None:
+            raise Indisponible(self.raison or "aucune console reliée")
+        env = self._environnement()
+        path = env.get("PATH", "")
+        if self._pont is not None and self._pont.vivant and path == self._path:
+            return self._pont
+        if self._pont is not None:
+            self._pont.fermer()
+            self._pont = None
+        elif time.monotonic() < self._retenter_a:
+            raise Indisponible(self.raison or "le pont n'a pas démarré")
+        pont = Pont(self.lien, env)
+        try:
+            pont.demarrer()
+        except Indisponible as err:
+            self.raison = str(err)
+            self._retenter_a = time.monotonic() + ATTENTE_APRES_ECHEC
+            raise
+        self._pont, self._path, self.raison, self.version = pont, path, "", pont.version
+        return pont
+
+    def demarrer(self) -> bool:
+        """Lance le pont à l'avance (au démarrage de la TUI). Renvoie False s'il n'est pas disponible."""
+        with self._verrou:
+            try:
+                self._pont_pret()
+                return True
+            except Indisponible:
+                return False
+
+    def _appel(self, op: str, **champs) -> dict:
+        with self._verrou:
+            pont = self._pont_pret()
+            try:
+                return pont.demander(op, **champs)
+            except Indisponible as err:
+                self.raison = str(err)
+                pont.fermer()
+                self._pont = None
+                self._retenter_a = time.monotonic() + ATTENTE_APRES_ECHEC
+                raise
+
+    def fermer(self) -> None:
+        with self._verrou:
+            if self._pont is not None:
+                self._pont.fermer()
+                self._pont = None
+
+    # ---- demandes
+    def verdict(self, commande: str, cwd: Path | str) -> Verdict | None:
+        """Verdict de la politique, ou None si elle n'est pas disponible (validation manuelle)."""
+        try:
+            return Verdict.depuis(self._appel("verdict", command=commande, cwd=str(cwd), mode=self.mode))
+        except Refus as err:
+            # Le pont refuse la demande elle-même (commande trop longue…) : c'est un refus, pas une panne
+            reason = Raison(code=err.code, message=str(err), plancher=True)
+            return Verdict(issue="refused", niveau="denied", mode=self.mode, raisons=(reason,), blocages=(reason,))
+        except Indisponible:
+            return None
+
+    def resume(self) -> dict | None:
+        """Liste blanche (nombres par niveau, ajouts, déblocages), dossiers d'écriture et cibles. None si indisponible."""
+        try:
+            return self._appel("politique")
+        except (Indisponible, Refus):
+            return None
+
+    def autoriser(self, noms: list[str]) -> dict:
+        return self._appel("autoriser", names=noms)
+
+    def retirer(self, noms: list[str]) -> dict:
+        return self._appel("retirer", names=noms)
+
+    def ajouter_cible(self, hote: str, note: str = "", sous_domaines: bool = False) -> dict:
+        """Déclare une cible. N'est appelée qu'après l'attestation de l'utilisateur."""
+        return self._appel("cible-ajouter", host=hote, note=note, includeSubdomains=sous_domaines, attest=True)
+
+    def retirer_cible(self, hote: str) -> dict:
+        return self._appel("cible-retirer", host=hote)

package/tui/promethee/preferences.py

@@ -0,0 +1,65 @@
+"""Préférences gardées d'un lancement à l'autre : politique d'exécution, fond de l'interface et, quand la TUI n'est pas
+reliée à la console, la recherche web (section « search », voir recherche.py)."""
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+
+from .config import SAVE_DIR
+
+FICHIER = SAVE_DIR / "preferences.json"
+# politique : « stricte » (liste blanche appliquée) ou « souple » (le hors-liste passe à ta validation)
+# fond : « promethee » (fond peint par l'application) ou « terminal » (fond de ton terminal)
+DEFAUT = {"politique": "stricte", "fond": "promethee"}
+VALEURS = {"politique": ("stricte", "souple"), "fond": ("promethee", "terminal")}
+
+
+def _brut(cible: Path) -> dict:
+    """Le fichier tel qu'il est enregistré, ou {} s'il est absent ou illisible."""
+    try:
+        saved = json.loads(cible.read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return {}
+    return saved if isinstance(saved, dict) else {}
+
+
+def _enregistrer(cible: Path, data: dict) -> None:
+    cible.parent.mkdir(parents=True, exist_ok=True)
+    tmp = cible.with_name(f".{cible.name}.tmp")
+    tmp.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
+    os.replace(tmp, cible)
+
+
+def lire(fichier: Path | None = None) -> dict[str, str]:
+    """Préférences enregistrées. Une valeur absente, illisible ou inconnue prend sa valeur par défaut."""
+    prefs = dict(DEFAUT)
+    saved = _brut(fichier or FICHIER)
+    for cle, permises in VALEURS.items():
+        if saved.get(cle) in permises:
+            prefs[cle] = saved[cle]
+    return prefs
+
+
+def ecrire(fichier: Path | None = None, **changements: str) -> dict[str, str]:
+    """Enregistre les préférences modifiées et renvoie l'ensemble. Une valeur inconnue lève ValueError.
+    Les autres sections du fichier (la recherche web) restent telles quelles."""
+    cible = fichier or FICHIER
+    prefs = lire(cible)
+    for cle, valeur in changements.items():
+        if valeur not in VALEURS.get(cle, ()):
+            raise ValueError(f"valeur inconnue pour « {cle} » : {valeur}")
+        prefs[cle] = valeur
+    _enregistrer(cible, {**_brut(cible), **prefs})
+    return prefs
+
+
+def lire_section(nom: str, fichier: Path | None = None):
+    """Une section enregistrée telle quelle (None si elle manque). C'est à l'appelant de la valider."""
+    return _brut(fichier or FICHIER).get(nom)
+
+
+def ecrire_section(nom: str, valeur, fichier: Path | None = None) -> None:
+    """Enregistre une section sans toucher aux autres."""
+    cible = fichier or FICHIER
+    _enregistrer(cible, {**_brut(cible), nom: valeur})