rapport_quotidien.py — rapport de situation et accès créateur autorisé

Nouveau composant du 01/08/2026 — rapport quotidien automatique et accès créateur via le futur site. S’appuie sur mode_reseau.py (déjà construit) pour vérifier la connexion, et sur code_rotatif.py pour l’authentification de l’accès créateur.

Principe

1. Une fois par jour minimum, si une connexion réseau existe, la clé envoie un rapport de situation (état, erreurs éventuelles) au site
2. Si pas de réseau ce jour-là, rien ne bloque MIRA — juste pas de rapport envoyé, retenté le jour suivant
3. Toi, le créateur, tu dois pouvoir accéder à une clé cliente via le site, mais uniquement avec une autorisation vérifiée (code_rotatif.py) — jamais un accès ouvert

import json
import logging
from pathlib import Path
from datetime import datetime, date

from mode_reseau import ModeReseau
from limiteur import Limiteur

BASE_DIR = Path(__file__).resolve().parent
DERNIER_RAPPORT_FILE = BASE_DIR / "config" / "dernier_rapport.json"

class RapportQuotidien:
    """
    Envoie un rapport de situation au site créateur, une fois par jour
    minimum, uniquement si une connexion réseau existe. Ne bloque jamais
    MIRA si le réseau est absent.
    """

    def __init__(self):
        self.reseau = ModeReseau()
        self.limiteur = Limiteur()

    def _rapport_deja_envoye_aujourdhui(self):
        if not DERNIER_RAPPORT_FILE.exists():
            return False
        with open(DERNIER_RAPPORT_FILE, "r", encoding="utf-8") as f:
            data = json.load(f)
        return data.get("date") == date.today().isoformat()

    def construire_rapport(self):
        """Rassemble l'état de MIRA à envoyer — pas de contenu personnel,
        uniquement des indicateurs de fonctionnement."""
        return {
            "date": datetime.now().isoformat(timespec="seconds"),
            "mode": "createur" if self.limiteur.est_createur() else "client",
            "statut_abonnement": self.limiteur.statut_abonnement()["statut"],
            "erreurs_recentes": self._lire_dernieres_erreurs(),
        }

    def _lire_dernieres_erreurs(self, nb_lignes=10):
        fichier_log = BASE_DIR / "logs" / "mira.log"
        if not fichier_log.exists():
            return []
        lignes = fichier_log.read_text(encoding="utf-8", errors="replace").splitlines()
        return [l for l in lignes if "ERROR" in l][-nb_lignes:]

    def envoyer_si_necessaire(self, fonction_envoi=None):
        """
        fonction_envoi : callable(rapport) → bool, injectée une fois le
        site créateur construit. Tant qu'elle n'existe pas, le rapport est
        préparé mais pas transmis.
        """
        if self._rapport_deja_envoye_aujourdhui():
            return {"statut": "deja_envoye"}
        if not self.reseau.disponible():
            return {"statut": "hors_ligne", "message": "Pas de réseau aujourd'hui — réessai demain."}

        rapport = self.construire_rapport()

        if fonction_envoi is None:
            return {"statut": "site_non_construit", "rapport": rapport}

        try:
            reussi = fonction_envoi(rapport)
            if reussi:
                DERNIER_RAPPORT_FILE.parent.mkdir(parents=True, exist_ok=True)
                with open(DERNIER_RAPPORT_FILE, "w", encoding="utf-8") as f:
                    json.dump({"date": date.today().isoformat()}, f)
            return {"statut": "envoye" if reussi else "echec"}
        except Exception as e:
            logging.error(f"Échec envoi rapport quotidien : {e}")
            return {"statut": "erreur", "message": str(e)}

Accès créateur via le site (principe, à construire avec le site)

• Toi, sur le site, tu demandes l’accès à une clé cliente précise
• Le site te donne le code du moment (via code_rotatif.py, la même base secrète que la clé)
• La clé vérifie ce code avant d’autoriser quoi que ce soit — aucun accès sans passer par cette vérification, même pour toi

Ce que ça respecte du reste de l’architecture

• Aucune donnée personnelle du client dans le rapport — uniquement des indicateurs techniques (statut, erreurs)
• Le réseau reste optionnel au quotidien pour l’usage de MIRA — seul l’envoi du rapport en dépend, jamais le fonctionnement de base