limiteur.py — licence créateur/client, abonnement, mises à jour

Nouveau composant du 01/08/2026 — "le limiteur". Distingue le mode créateur (toi, Mario ANTARES — aucune limite, aucune restriction) du mode client (abonnement, vérification périodique obligatoire, mises à jour uniquement si tu les autorises). Prévu pour une future clé vendue à un client, avec connexion périodique à un site à construire plus tard.

Principe

• Mode créateur : par défaut, sans restriction. C’est l’état actuel de tout ce qu’on construit.
• Mode client : activé uniquement au moment de préparer une clé pour la vente. Le client doit se reconnecter selon la période choisie (mensuelle, semestrielle, annuelle — à la date anniversaire ou avant, une fois l’abonnement payé). S’il ne se reconnecte pas, MIRA cesse de répondre jusqu’à la prochaine vérification réussie.
• Mises à jour côté client : bloquées par défaut, ne s’activent que si toi, le créateur, les autorises explicitement.

import json
from pathlib import Path
from datetime import datetime, timedelta

BASE_DIR = Path(__file__).resolve().parent
LICENCE_FILE = BASE_DIR / "licence.json"

MODE_CREATEUR = "createur"
MODE_CLIENT = "client"

PERIODES_VALIDES = {
    "mensuel": 30,
    "semestriel": 182,
    "annuel": 365,
}

class Limiteur:
    """
    Mode créateur : aucune limite, aucune restriction, jamais.
    Mode client : vérification périodique obligatoire, mises à jour
    bloquées sauf autorisation explicite du créateur.
    """

    def __init__(self):
        self.licence = self._charger_licence()

    def _charger_licence(self):
        if not LICENCE_FILE.exists():
            # Par défaut : mode créateur. Une clé ne devient "client" que
            # lorsque tu génères explicitement une licence pour une vente.
            return {"mode": MODE_CREATEUR}
        with open(LICENCE_FILE, "r", encoding="utf-8") as f:
            return json.load(f)

    def _sauvegarder_licence(self):
        with open(LICENCE_FILE, "w", encoding="utf-8") as f:
            json.dump(self.licence, f, indent=4, ensure_ascii=False)

    def generer_licence_client(self, periode="mensuel", date_debut=None):
        """
        RÉSERVÉ AU CRÉATEUR : transforme une installation en licence client.
        À utiliser uniquement sur une clé destinée à la vente, jamais sur
        ta propre clé de travail.
        """
        if periode not in PERIODES_VALIDES:
            raise ValueError(f"Période invalide : {periode}")

        date_debut = date_debut or datetime.now()
        self.licence = {
            "mode": MODE_CLIENT,
            "periode": periode,
            "date_derniere_verification": date_debut.isoformat(timespec="seconds"),
            "mise_a_jour_autorisee": False,
        }
        self._sauvegarder_licence()
        return f"Licence client générée : vérification {periode}."

    def est_createur(self):
        return self.licence.get("mode") == MODE_CREATEUR

    def statut_abonnement(self):
        """
        Le créateur est toujours "actif", sans exception. Le client doit
        s'être reconnecté dans la période prévue.
        """
        if self.est_createur():
            return {"statut": "actif", "message": "Mode créateur — aucune restriction."}

        derniere = datetime.fromisoformat(self.licence["date_derniere_verification"])
        limite_jours = PERIODES_VALIDES[self.licence["periode"]]
        expiration = derniere + timedelta(days=limite_jours)

        if datetime.now() > expiration:
            return {
                "statut": "expire",
                "message": "Abonnement expiré — connexion requise pour continuer à utiliser MIRA."
            }
        return {"statut": "actif", "message": f"Abonnement valide jusqu'au {expiration.date()}."}

    def enregistrer_verification(self, verification_reussie):
        """Appelé après une vérification réussie via le futur site de licence."""
        if not verification_reussie or self.est_createur():
            return
        self.licence["date_derniere_verification"] = datetime.now().isoformat(timespec="seconds")
        self._sauvegarder_licence()

    def peut_se_mettre_a_jour(self):
        """Le créateur peut toujours mettre à jour. Le client, seulement si autorisé."""
        if self.est_createur():
            return True
        return self.licence.get("mise_a_jour_autorisee", False)

    def autoriser_mise_a_jour_client(self, autoriser=True):
        """RÉSERVÉ AU CRÉATEUR."""
        self.licence["mise_a_jour_autorisee"] = autoriser
        self._sauvegarder_licence()

Points d’intégration à prévoir (pas encore réécrits dans les fichiers existants)

1. moteur_ia.py : repondre() doit vérifier limiteur.statut_abonnement() avant de répondre — si "expiré", renvoyer le message d’expiration au lieu d’une vraie réponse
2. interface_demarrage.py : ajouter_utilisateur() doit refuser la création d’un 2e compte si limiteur.est_createur() est faux (un seul utilisateur autorisé en mode client)
3. Le futur site de licence : enregistrer_verification() sera appelé depuis là une fois construit — squelette volontairement ouvert, comme pour mode_reseau.py

Précision importante

Ceci reste totalement indépendant du reste de MIRA — c’est une couche de contrôle commercial, pas une fonctionnalité de l’IA. En mode créateur (ta situation actuelle), rien ne change à ce qu’on a construit ce soir.