feat: Initialisation du nouveau dépôt 'mayproject' à partir de 'ernestmind'.

a6ea61c8-951a-413a-ba9d-7365d83fbd4d/mayproject/Dockerfile

@@ -0,0 +1,67 @@
+# ÉTAPE 1: Image de base
+FROM python:3.11-slim
+
+# ÉTAPE 2: Configuration et Dossier de travail
+# Nous laissons Render injecter le port via $PORT
+ENV FLASK_APP app.py
+# Suppression des variables GUNICORN_WORKERS et GUNICORN_THREADS car elles sont gérées
+# de manière plus efficace et simple dans entrypoint.sh avec Eventlet.
+
+# Création et utilisation du répertoire /app
+WORKDIR /app
+
+# ÉTAPE 3: Installation des dépendances (OPTIMISATION CACHING)
+# Copie uniquement de requirements.txt pour mettre en cache l'installation
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt \
+    && rm requirements.txt
+
+# ÉTAPE 4: Copie de l'Application et des Fichiers
+# CORRECTION MAJEURE : Ajout du dossier templates
+COPY templates /app/templates
+
+# Copie des autres fichiers (y compris app.py, votre point d'entrée)
+COPY app.py .
+COPY config.py .
+COPY user_routes.py .
+COPY web_routes.py .
+COPY decorators.py .
+COPY billing_routes.py .
+COPY auth_backend.py .
+COPY baserow_storage.py .
+COPY huggingface_storage.py .
+COPY pr_routes.py .
+COPY pull_request_backend.py .
+COPY issues_backend.py .
+COPY issue_routes.py .
+COPY project_routes.py .
+COPY huggingface_repo_manager.py .
+COPY hf_deploy_manager.py .
+COPY deployment_routes.py .
+COPY gemini_functions.py .
+COPY gemini_routes.py .
+COPY repo_settings_routes.py .
+COPY repo_settings_manager.py .
+
+
+# Copie du script d'entrée
+COPY entrypoint.sh .
+
+# NOUVEAU: CORRECTION DES FINS DE LIGNE (Résout 'exec ./entrypoint.sh: no such file or directory')
+# Supprime le caractère de retour chariot (\r)
+RUN sed -i 's/\r$//' entrypoint.sh
+
+# Le rendre exécutable
+RUN chmod +x entrypoint.sh
+
+# ÉTAPE 5: Sécurité et Exécution
+# Création et bascule vers l'utilisateur non-root ('user') pour la sécurité
+RUN useradd -ms /bin/bash user
+RUN chown -R user:user /app
+USER user
+
+# Indique à Docker que le conteneur écoute sur ce port
+EXPOSE $PORT
+
+# Lance l'application via le script d'entrée
+CMD ["./entrypoint.sh"]

a6ea61c8-951a-413a-ba9d-7365d83fbd4d/mayproject/README.md

@@ -0,0 +1,5 @@
+# Dépôt ernestmind
+
+Bienvenue sur votre dépôt GitForge, hébergé sur Mailix.
+
+Commencez par ajouter ou créer des fichiers.

a6ea61c8-951a-413a-ba9d-7365d83fbd4d/mayproject/app.py

@@ -0,0 +1,377 @@
+# app.py
+import requests
+import json
+import os
+import sys
+import io 
+import uuid 
+from functools import wraps
+from datetime import datetime 
+from flask import Flask, request, jsonify, Response, session
+from flask_cors import CORS
+import baserow_storage # Assurez-vous que ceci est présent
+import shutil
+from flask_socketio import SocketIO 
+import huggingface_storage # <-- NOUVEL IMPORT
+import huggingface_storage # <-- NOUVEL IMPORT
+# NOUVEL IMPORT POUR LA GESTION DU TERMINAL
+
+# Importation des modules backend
+from auth_backend import ( 
+    get_user_by_id,
+    login_user, 
+    register_user, 
+    generate_api_key, 
+    get_plan_limit, 
+    reset_password_via_security_question, 
+    generate_password_hash,
+)
+from decorators import api_key_required # <-- NOUVEL IMPORT
+from flask_cors import CORS # <--- S'assurer que l'importation est là
+from project_routes import project_bp # Si vous nommez le nouveau Blueprint 'project_bp'
+from web_routes import web_bp
+from user_routes import user_bp
+from billing_routes import billing_bp
+from pr_routes import pr_bp # <-- NOUVEL IMPORT
+from issue_routes import issue_bp # <-- NOUVEL IMPORT
+from baserow_storage import check_critical_fields_existence
+from deployment_routes import hf_deploy_bp # <-- IMPORT CRITIQUE
+from gemini_routes import gemini_bp
+from repo_settings_routes import settings_bp # Assurez-vous du chemin correct
+DEFAULT_MAX_CONTENT_LENGTH = 16 * 1024 * 1024 
+
+# Dossier pour le stockage temporaire des fichiers HTML uploadés
+# Nous utilisons un dossier 'temp_uploads' à la racine de l'application
+UPLOAD_FOLDER = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'temp_uploads')
+if not os.path.exists(UPLOAD_FOLDER):
+    os.makedirs(UPLOAD_FOLDER) # Créer le dossier s'il n'existe pas
+
+# Extensions de fichiers autorisées (très important pour la sécurité)
+ALLOWED_EXTENSIONS = {'html', 'htm'}
+
+# --- Initialisation de l'Application Flask (DÉPLACÉ ICI pour corriger le NameError) ---
+app = Flask(__name__)
+
+app.config['HF_DATASET_REPO_ID'] = os.environ.get('HF_DATASET_REPO_ID')
+
+# Maintenant, 'app' est défini et on peut lui appliquer des configurations
+app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
+app.config['ALLOWED_EXTENSIONS'] = ALLOWED_EXTENSIONS
+
+from werkzeug.middleware.proxy_fix import ProxyFix
+app.wsgi_app = ProxyFix(app.wsgi_app, x_for=1, x_proto=1, x_host=1, x_port=1, x_prefix=1)
+# ------------------------------------------------------------------
+
+# car Hugging Face utilise souvent Gunicorn avec ces workers.
+socketio = SocketIO(app, cors_allowed_origins="*")
+
+
+# Configuration
+app.secret_key = os.environ.get("FLASK_SECRET_KEY", "super_secret_dev_key") 
+app.config['MAX_CONTENT_LENGTH'] = DEFAULT_MAX_CONTENT_LENGTH 
+
+# Permettre les requêtes cross-origin (CORS)
+CORS(app, supports_credentials=True, origins="*", allow_headers=["Content-Type", "X-User-API-Key"])
+
+
+# Permettre les requêtes cross-origin pour l'API
+CORS(app) 
+
+app.register_blueprint(hf_deploy_bp) # <-- ENREGISTREZ LE NOUVEAU BLUEPRINT
+app.register_blueprint(web_bp)
+app.register_blueprint(user_bp) 
+app.register_blueprint(billing_bp)
+app.register_blueprint(pr_bp) # <-- NOUVEL ENREGISTREMENT
+app.register_blueprint(issue_bp) # <-- NOUVEL ENREGISTREMENT
+app.register_blueprint(project_bp)
+app.register_blueprint(settings_bp)
+app.register_blueprint(gemini_bp)
+
+# --- Décorateurs d'Authentification (Correction) ---
+def login_required(f):
+    @wraps(f)
+    def decorated_function(*args, **kwargs):
+        user_id = session.get('user_id')
+        
+        if not user_id:
+            # Redirection HTTP 302 vers la page de connexion pour les requêtes non-API
+            if not request.path.startswith('/api/'):
+                from flask import redirect, url_for
+                # NOTE: Il se peut que 'user_bp.connexion' ne soit pas la bonne route. 
+                # Si c'est dans web_bp, utilisez web_bp.connexion_page comme dans user_routes.py
+                return redirect(url_for('web_bp.connexion_page')) # CORRECTION POTENTIELLE DE LA REDIRECTION
+            # Réponse JSON pour les API
+            return jsonify({"status": "Error", "message": "Accès non autorisé. Veuillez vous connecter.", "code": "AUTH_REQUIRED"}), 401
+
+        # 1. Récupérer les données utilisateur
+        user = get_user_by_id(user_id)
+        
+        if not user:
+            # Si l'ID est dans la session mais l'utilisateur n'existe plus en DB
+            session.pop('user_id', None)
+            from flask import redirect, url_for
+            return redirect(url_for('web_bp.connexion_page')) # Rediriger l'utilisateur déconnecté
+            
+        # 2. Injecter les données utilisateur dans la fonction de vue
+        return f(user=user, *args, **kwargs) # <--- CORRECTION CLÉ : Ajout de user=user
+    return decorated_function
+
+
+# --- Routes d'Authentification (API - Conservées) ---
+
+@app.route("/api/register", methods=["POST"])
+def register():
+    data = request.get_json()
+    username = data.get("username")
+    email = data.get("email")
+    password = data.get("password")
+    confirm_password = data.get("confirm_password")
+    security_question = data.get("security_question")
+    security_answer = data.get("security_answer")
+
+    # CORRECTION ICI: Déballage des 3 valeurs retournées par register_user
+    user_id, message, new_user_data = register_user(username, email, password, confirm_password, security_question, security_answer)
+
+    if user_id and new_user_data: # Vérifier l'ID et les données pour s'assurer du succès
+        session['user_id'] = user_id
+        
+        # Réponse JSON pour l'API, incluant la clé API
+        return jsonify({
+            "message": message, 
+            "status": "Success", 
+            "user_id": user_id, 
+            # On récupère la clé API directement des données utilisateur
+            "api_key": new_user_data.get("api_key") 
+            }), 201
+    else:
+        # Échec de l'inscription (message d'erreur de register_user)
+        return jsonify({"message": message, "status": "Error"}), 400
+
+
+
+@app.route("/api/login", methods=["POST"])
+def login():
+    """
+    Route de connexion de l'utilisateur principal.
+    Prend le nom d'utilisateur/email et le mot de passe.
+    """
+    data = request.get_json()
+    username = data.get("username") 
+    password = data.get("password")
+
+    # CORRECTION DE L'ERREUR :
+    # Nous déballons maintenant 3 valeurs (ID, Message, Données Utilisateur)
+    # car la fonction login_user() dans auth_backend.py a été modifiée pour 
+    # retourner les 3 valeurs.
+    user_id, message, user_data = login_user(username, password)
+
+    # Note: user_data est la 3ème valeur (Dict des données utilisateur ou None)
+    if user_id and user_data: 
+        # La connexion est réussie
+        session['user_id'] = user_id
+        
+        # Réponse API avec la clé API de l'utilisateur pour les futures requêtes
+        return jsonify({
+            "message": message, 
+            "status": "Success", 
+            "user_id": user_id, 
+            # On utilise les données utilisateur (user_data) que nous avons déjà récupérées
+            "api_key": user_data.get("api_key") 
+        }), 200
+    else:
+        # La connexion a échoué (identifiants invalides ou autre erreur)
+        return jsonify({"message": message, "status": "Error"}), 401
+
+@app.route("/api/logout", methods=["POST"])
+def logout():
+    session.pop('user_id', None)
+    return jsonify({"message": "Déconnexion réussie.", "status": "Success"}), 200
+
+@app.route("/api/forgot-password", methods=["POST"])
+def forgot_password_api(): # Renommée pour éviter conflit avec la route HTML
+    data = request.get_json()
+    username_or_email = data.get("username_or_email")
+    security_answer = data.get("security_answer")
+    new_password = data.get("new_password")
+    
+    if not username_or_email or not security_answer or not new_password:
+        return jsonify({"message": "Champs manquants.", "status": "Error"}), 400
+        
+    success, message = reset_password_via_security_question(username_or_email, security_answer, new_password)
+    
+    if success:
+        return jsonify({
+            "message": message,
+            "status": "Success"
+        }), 200
+    else:
+        return jsonify({
+            "message": message,
+            "status": "Error"
+        }), 400
+
+
+# --- Routes de Gestion de Compte (API - Conservées) ---
+
+@app.route("/api/user/generate-key", methods=["POST"])
+@login_required
+def generate_user_api_key():
+    user_id = session.get('user_id')
+    
+    new_api_key = create_dynamic_api_key()
+    
+    success, message = update_user_data(user_id, {"api_key": new_api_key})
+    
+    if success:
+        return jsonify({
+            "message": "Clé API utilisateur générée et sauvegardée. Conservez-la en lieu sûr. **Utilisez-la via URL simple ('api_key=...') ou en-tête 'X-User-API-Key'.**",
+            "status": "Success",
+            "api_key": new_api_key
+        }), 200
+    else:
+        return jsonify({
+            "message": f"Erreur lors de la génération de la clé : {message}",
+            "status": "Error"
+        }), 500
+
+@app.route("/api/user/update-info", methods=["POST"])
+@login_required
+def update_user_info():
+    user_id = session.get('user_id')
+    data = request.get_json()
+    
+    updates = {}
+    if 'username' in data: 
+        updates['username'] = data['username']
+    if 'email' in data:
+        updates['email'] = data['email']
+    if 'plan' in data:
+        updates['plan'] = data['plan']
+        
+    if not updates:
+        return jsonify({
+            "message": "Aucune information à mettre à jour fournie.",
+            "status": "Error"
+        }), 400
+        
+    success, message = update_user_data(user_id, updates)
+
+    if success:
+        return jsonify({
+            "message": message,
+            "status": "Success"
+        }), 200
+    else:
+        return jsonify({
+            "message": f"Échec de la mise à jour : {message}",
+            "status": "Error"
+        }), 400
+
+
+
+@app.route("/api/user-info", methods=["GET"])
+@api_key_required
+def api_user_info(client_user):
+    """
+    Route API pour récupérer les informations de l'utilisateur principal (client)
+    à partir de la clé API fournie.
+    Le 'client_user' est injecté par le décorateur api_key_required.
+    """
+    # client_user est l'objet utilisateur complet injecté par le décorateur
+    
+    # Sécurité : créer une copie et supprimer les données sensibles avant l'envoi
+    user_info_safe = client_user.copy()
+    user_info_safe.pop('password_hash', None)
+    user_info_safe.pop('security_answer_hash', None)
+    
+    return jsonify({
+        "message": "Informations utilisateur récupérées avec succès.",
+        "status": "Success", 
+        "user": user_info_safe
+    }), 200
+
+
+
+@app.route("/api/health", methods=["GET"])
+def health_check():
+    """Vérifie l'état du service en utilisant le statut Baserow."""
+    
+    # 1. Tenter d'obtenir le statut Baserow réel
+    try:
+        # Appelle la fonction de baserow_storage pour vérifier l'état
+        health_status = baserow_storage.get_health_status()
+        
+        # Le statut 'data_storage' est la clé pour le frontend
+        db_status_message = health_status.get('data_storage', 'Unknown')
+        
+        # Si la DB est 'operational', on envoie 'Ready'
+        if db_status_message == 'operational':
+             data_status = "Ready"
+        else:
+             data_status = f"Failed (Baserow: {db_status_message})"
+             
+    except Exception as e:
+        # Erreur générale, Baserow inaccessible ou problème de configuration critique
+        data_status = f"Failed (Exception: {str(e)})"
+        
+    return jsonify({
+        "status": "Online",
+        "data_storage": data_status
+    }), 200
+
+@app.route("/", methods=["GET"])
+def read_root():
+    """Endpoint racine pour le Health Check (Flask version)."""
+    
+    if baserow_storage.is_baserow_up():
+        # Statut OK (200) avec le message
+        return jsonify({"status": "ok", "message": "Backend and Baserow API are reachable."}), 200
+    else:
+        # Statut de service non disponible (503) avec le message d'erreur
+        return jsonify({"detail": "Baserow service unavailable (Health Check failed)."}), 503
+
+
+
+def perform_startup_checks():
+    """
+    Exécute des vérifications critiques au démarrage (Baserow et Hugging Face)
+    pour que les problèmes de configuration soient visibles dans les logs de Render.
+    """
+    print("\n--- DÉBUT DES VÉRIFICATIONS DE DÉMARRAGE CRITIQUES ---", file=sys.stderr)
+    
+    # --- 1. VÉRIFICATION BASEROW (Connexion et Champs) ---
+    baserow_config_status = baserow_storage.check_baserow_connection()
+    
+    if baserow_config_status != "operational":
+        print(f"CRITIQUE: Configuration Baserow ÉCHOUÉE: {baserow_config_status}", file=sys.stderr)
+    else:
+        print("SUCCÈS: Configuration Baserow (Tokens/IDs) trouvée.", file=sys.stderr)
+        
+        # 1.1 VÉRIFICATION DE L'ÉTAT DU SERVICE BASEROW
+        if not baserow_storage.is_baserow_up():
+            print("CRITIQUE: Baserow est configuré mais le Health Check API a ÉCHOUÉ (Vérifiez la connexion ou le token).", file=sys.stderr)
+        else:
+            print("SUCCÈS: Connexion Baserow API OK.", file=sys.stderr)
+            
+            # NOUVEAU: 1.2 VÉRIFICATION DE L'EXISTENCE DES CHAMPS CRITIQUES
+            fields_check_status = baserow_storage.check_critical_fields_existence()
+            if fields_check_status != "operational":
+                print(f"CRITIQUE: Vérification des Champs Baserow ÉCHOUÉE: {fields_check_status}", file=sys.stderr)
+            else:
+                print("SUCCÈS: Tous les champs critiques de la table Baserow sont présents.", file=sys.stderr)
+            
+    # --- 2. VÉRIFICATION HUGGING FACE (Stockage de Dépôt) ---
+    hf_repo_id = os.environ.get("HF_DATASET_REPO_ID")
+    hf_token = os.environ.get("HF_TOKEN")
+    
+    if not hf_repo_id:
+        print("CRITIQUE: HF_DATASET_REPO_ID est MANQUANT. Impossible de créer un dépôt.", file=sys.stderr)
+    elif not hf_token:
+        print("ATTENTION: HF_TOKEN est MANQUANT. Les opérations Hugging Face pourraient échouer sans jeton dans l'environnement.", file=sys.stderr)
+    else:
+        print(f"SUCCÈS: Configuration Hugging Face (Repo ID: {hf_repo_id}) trouvée.", file=sys.stderr)
+        
+    print("--- FIN DES VÉRIFICATIONS DE DÉMARRAGE CRITIQUES ---\n", file=sys.stderr)
+
+# Exécutez les vérifications au démarrage de Gunicorn
+perform_startup_checks()

a6ea61c8-951a-413a-ba9d-7365d83fbd4d/mayproject/auth_backend.py

@@ -0,0 +1,371 @@
+# auth_backend.py
+
+import json
+import uuid
+import secrets 
+import string 
+import sys # Nécessaire pour print(..., file=sys.stderr)
+from datetime import datetime
+from werkzeug.security import generate_password_hash, check_password_hash
+from huggingface_repo_manager import initialize_user_hf_folder # <--- AJOUTEZ CET IMPORT
+# Ces fonctions sont maintenant implémentées dans baserow_storage.py
+from baserow_storage import (
+    # Fonctions de lecture/écriture pour les utilisateurs principaux (simulant l'ancienne API)
+    get_client_user_by_api_key,
+    load_primary_user_data,
+    save_primary_user_data,
+    # Fonctions de recherche indexées (nouvelles et plus efficaces)
+    get_user_by_email,
+    get_client_user_by_api_key, 
+    FIELD_USER_TYPE, 
+    FIELD_CLIENT_ID,
+)
+
+from config import PLANS_CONFIG 
+from typing import Optional, Dict 
+
+# ----------------------------------------------------------------------
+# --- Fonctions Utilitaires et de Configuration ---
+# ----------------------------------------------------------------------
+
+def get_plan_limit(plan: str) -> float: 
+    """Retourne la limite de compte pour un plan donné."""
+    return PLANS_CONFIG.get(plan, {}).get("limit", PLANS_CONFIG["free"]["limit"])
+
+def get_plan_details(plan_id: str) -> Optional[Dict]:
+    """Retourne les détails complets d'un plan à partir de son ID."""
+    return PLANS_CONFIG.get(plan_id)
+
+def generate_api_key(length: int = 32) -> str:
+    """Génère une clé API sécurisée."""
+    chars = string.ascii_letters + string.digits
+    return ''.join(secrets.choice(chars) for _ in range(length))
+
+# ----------------------------------------------------------------------
+# --- Fonctions d'Authentification WEB (Primary Users) ---
+# ----------------------------------------------------------------------
+
+
+def register_user(username: str, email: str, password: str, confirm_password: str, security_question: str, security_answer: str) -> tuple[Optional[str], str, Optional[Dict]]:
+    """
+    Tente d'enregistrer un nouvel utilisateur principal.
+    Retourne l'ID utilisateur (str), un message (str), et les données utilisateur complètes (Dict) ou None.
+    """
+    email = email.lower().strip()
+    
+    # Validation du formulaire
+    if not all([username, email, password, confirm_password, security_question, security_answer]):
+        # Retourne (ID, message, Data)
+        return None, "Tous les champs sont requis.", None
+        
+    if password != confirm_password:
+        return None, "Les mots de passe ne correspondent pas.", None
+        
+    if len(password) < 8:
+        return None, "Le mot de passe est trop court (min 8 caractères).", None
+
+    # 1. Vérification de l'existence de l'utilisateur par email
+    if get_user_by_email(email):
+        return None, "Un compte avec cette adresse e-mail existe déjà.", None
+
+    # 2. Hachage des données
+    password_hash = generate_password_hash(password)
+    security_answer_hash = generate_password_hash(security_answer.lower())
+    
+    # 3. Création des données utilisateur
+    user_id = str(uuid.uuid4())
+    # Ligne optimisée: on génère les 5 clés en une seule liste
+    api_keys = [generate_api_key() for _ in range(5)] 
+    
+    new_user = {
+        'user_id': user_id,
+        'username': username,
+        'email': email,
+        'password_hash': password_hash,
+        # ASSIGNATION DES 5 CLÉS API AUX CHAMPS CORRESPONDANTS
+        'api_key': api_keys[0],
+        'api_key_2': api_keys[1],
+        'api_key_3': api_keys[2],
+        'api_key_4': api_keys[3],
+        'api_key_5': api_keys[4],
+        'security_question': security_question,
+        'security_answer_hash': security_answer_hash,
+        'plan_id': PLANS_CONFIG['free']['baserow_value'],
+        'stripe_subscription_id': None, # Pas d'abonnement Stripe au début
+        'date_creation': datetime.now().isoformat(),
+        'date_plan_start': datetime.now().isoformat(),
+        'api_calls_month': 0,
+        'status': 'Active',
+        'baserow_row_id': None, # Sera rempli par la fonction save_primary_user_data si c'est une création
+        # Note: D'autres champs pourraient être nécessaires ici, selon les besoins non-vus
+    }
+
+    # 4. Sauvegarde dans Baserow 
+    # La fonction save_primary_user_data mettra à jour 'baserow_row_id' dans new_user si la création est réussie.
+    success = save_primary_user_data(new_user, commit_msg=f"feat: Création de l'utilisateur {user_id} ({email})")
+    
+    if success:
+        # Retourne : ID utilisateur, message de succès, Dictionnaire utilisateur complet
+        return user_id, "Inscription réussie. Vous pouvez maintenant vous connecter.", new_user
+    else:
+        # Échec de l'écriture dans la BDD (Baserow)
+        # Retourne : None, message d'erreur, None
+        return None, "Erreur interne lors de l'enregistrement de l'utilisateur.", None
+        
+def login_user(username_or_email: str, password: str) -> tuple[Optional[str], str, Optional[Dict]]: # <-- NOUVEAU: Ajout de Optional[Dict] dans le type hint
+    """
+    Tente de connecter un utilisateur principal.
+    Retourne l'ID utilisateur (str), un message (str) et les données utilisateur (Dict).
+    """
+    username_or_email = username_or_email.lower().strip()
+    
+    # 1. Recherche de l'utilisateur par email (Utilisation de la nouvelle fonction rapide Baserow)
+    user = get_user_by_email(username_or_email)
+    
+    if user:
+        # 2. Vérification du mot de passe
+        if check_password_hash(user['password_hash'], password):
+            # CORRECTION : Retourne 3 valeurs : ID, Message, Données Utilisateur
+            return user['user_id'], "Connexion réussie.", user 
+
+    # CORRECTION : Retourne 3 valeurs : None ID, Message, None Data
+    return None, "Email/Nom d'utilisateur ou mot de passe invalide.", None
+
+
+def get_user_by_id(user_id: str) -> Optional[Dict]:
+    """
+    Récupère un utilisateur principal par son ID.
+    Utilise la fonction load_primary_user_data (qui est get_user_by_id dans Baserow).
+    """
+    return load_primary_user_data(user_id)
+    
+def get_user_by_api_key(api_key: str) -> Optional[Dict]:
+    """
+    Récupère un utilisateur principal par sa Clé API (utilisé par le décorateur).
+    Utilise la nouvelle fonction indexée et rapide de Baserow.
+    """
+    return get_client_user_by_api_key(api_key)
+
+
+def reset_password_via_security_question(username_or_email: str, question: str, answer: str, new_password: str) -> tuple[bool, str]:
+    """Réinitialise le mot de passe via la question de sécurité."""
+    username_or_email = username_or_email.lower().strip()
+    
+    # Validation du mot de passe
+    if len(new_password) < 8:
+        return False, "Le nouveau mot de passe est trop court (min 8 caractères)."
+
+    # 1. Recherche de l'utilisateur
+    user = get_user_by_email(username_or_email)
+    
+    if not user:
+        return False, "Utilisateur introuvable."
+        
+    # 2. Vérification de la question/réponse
+    if user.get('security_question') != question:
+        return False, "Question de sécurité incorrecte."
+        
+    if not check_password_hash(user.get('security_answer_hash', ''), answer.lower()):
+        return False, "Réponse de sécurité incorrecte."
+        
+    # 3. Hachage du nouveau mot de passe
+    new_hashed_password = generate_password_hash(new_password)
+    
+    # 4. Mise à jour et sauvegarde en BDD (Baserow)
+    user['password_hash'] = new_hashed_password
+    
+    success = save_primary_user_data(user, commit_msg=f"feat: Réinitialisation MDP utilisateur {user['user_id']}")
+    
+    if success:
+        return True, "Mot de passe réinitialisé avec succès."
+    else:
+        return False, "Erreur interne lors de la mise à jour du mot de passe."
+
+
+def update_user_plan(user_id: str, new_plan_id: str, stripe_subscription_id: Optional[str]) -> bool:
+    """Met à jour le plan et l'ID d'abonnement Stripe pour un utilisateur."""
+    
+    user = get_user_by_id(user_id)
+    
+    if not user:
+        print(f"Erreur: Utilisateur {user_id} non trouvé pour la mise à jour du plan.", file=sys.stderr)
+        return False
+
+    user['plan_id'] = new_plan_id
+    user['stripe_subscription_id'] = stripe_subscription_id
+    user['date_plan_start'] = datetime.now().isoformat()
+    
+    success = save_primary_user_data(user, commit_msg=f"feat: Mise à jour du plan pour {user_id} vers {new_plan_id}")
+    
+    return success
+
+
+def update_user_profile(user_id: str, username: str, email: str, new_password: Optional[str] = None) -> tuple[bool, str]:
+    """
+    Met à jour le profil de l'utilisateur principal (client).
+    user_id: L'UUID de l'utilisateur.
+    username: Le nouveau nom d'utilisateur.
+    email: Le nouvel email.
+    new_password: Le nouveau mot de passe (si fourni et non vide).
+    """
+    
+    # 1. Chargement des données existantes
+    user_data = load_primary_user_data(user_id)
+    if not user_data:
+        return False, "Erreur critique : Utilisateur introuvable pour la mise à jour."
+        
+    original_email = user_data.get('email')
+    
+    # 2. Validation et mise à jour de l'email
+    if email and email != original_email:
+        # Vérification si le nouvel email n'est pas déjà utilisé par un autre utilisateur
+        # Note: get_user_by_email retourne l'objet utilisateur, pas juste l'ID.
+        existing_user_by_email = get_user_by_email(email)
+        
+        # S'il trouve un utilisateur ET que son ID ne correspond pas à l'utilisateur actuel,
+        # l'email est déjà pris.
+        if existing_user_by_email and existing_user_by_email.get('user_id') != user_id:
+            return False, "Cet email est déjà utilisé par un autre compte."
+        
+        # Mise à jour de l'email si la validation passe
+        user_data['email'] = email
+        
+    # 3. Mise à jour du nom d'utilisateur (pas de validation d'unicité assumée ici)
+    user_data['username'] = username
+    
+    # 4. Mise à jour du mot de passe (si un nouveau est fourni)
+    if new_password:
+        if len(new_password) < 8:
+            # Assurez-vous que cette limite est cohérente avec la fonction register_user
+            return False, "Le nouveau mot de passe est trop court (min 8 caractères)."
+            
+        user_data['password_hash'] = generate_password_hash(new_password)
+        
+    # 5. Sauvegarde des données
+    # Le row_id est stocké dans l'objet utilisateur après la première sauvegarde.
+    baserow_row_id = user_data.get('baserow_row_id')
+    
+    if baserow_row_id is None:
+        return False, "Erreur de configuration : ID de ligne Baserow manquant."
+        
+    if save_primary_user_data(user_data, commit_msg=f"feat: Mise à jour du profil utilisateur {user_id}"):
+        return True, "Votre profil a été mis à jour avec succès."
+    else:
+        return False, "Une erreur s'est produite lors de la sauvegarde du profil."
+
+def register_end_user(client_id: str, username: str, email: str, password: str, confirm_password: str) -> tuple[Optional[str], str, Optional[Dict]]:
+    """
+    Enregistre un nouvel utilisateur final (End User) lié à un utilisateur client (Primary User).
+    """
+    if password != confirm_password:
+        return None, "Les mots de passe ne correspondent pas.", None
+    if len(password) < 8:
+        return None, "Le mot de passe doit contenir au moins 8 caractères.", None
+
+    # Vérification de l'unicité de l'email UNIQUEMENT pour ce client et pour le type 'End'
+    existing_user_by_email = load_primary_user_data(
+        filters={
+            FIELD_EMAIL: email,
+            FIELD_USER_TYPE: 'End',
+            FIELD_CLIENT_ID: client_id
+        }
+    )
+    if existing_user_by_email:
+        return None, "Cet email est déjà utilisé pour votre service.", None
+
+    # 1. Création des données de l'utilisateur final
+    user_id = str(uuid.uuid4())
+    password_hash = generate_password_hash(password)
+    
+    new_user_data = {
+        FIELD_ID: user_id,
+        FIELD_EMAIL: email,
+        FIELD_USERNAME: username,
+        FIELD_PASSWORD_HASH: password_hash,
+        FIELD_DATE_CREATION: datetime.now().isoformat(),
+        FIELD_USER_TYPE: 'End',         # <-- IMPORTANT: Marquer comme utilisateur final
+        FIELD_CLIENT_ID: client_id,     # <-- IMPORTANT: Lier au client principal
+        FIELD_PLAN: PLANS_CONFIG['free']['baserow_value'], # Plan par défaut
+    }
+    
+    # 2. Sauvegarde dans Baserow (dans la même table)
+    success, row_id = save_primary_user_data(new_user_data, is_new=True)
+
+    if success:
+        new_user_data['baserow_row_id'] = row_id 
+        return user_id, "Inscription réussie !", new_user_data
+    else:
+        return None, f"Erreur lors de l'enregistrement dans la base de données. ID: {user_id}", None
+
+def login_end_user(client_id: str, email: str, password: str) -> tuple[Optional[str], str, Optional[Dict]]:
+    """
+    Connecte un utilisateur final (End User) lié à un client donné.
+    """
+    user_data_list = load_primary_user_data(
+        filters={
+            FIELD_EMAIL: email,
+            FIELD_USER_TYPE: 'End', # Filtrer uniquement les utilisateurs finaux
+            FIELD_CLIENT_ID: client_id # Filtrer par l'ID du client
+        }
+    )
+    
+    if not user_data_list:
+        return None, "Email ou mot de passe invalide.", None
+    
+    user_data = user_data_list[0]
+    
+    if check_password_hash(user_data.get(FIELD_PASSWORD_HASH), password):
+        return user_data.get(FIELD_ID), "Connexion réussie.", user_data
+    else:
+        return None, "Email ou mot de passe invalide.", None
+
+def reset_end_user_password(client_id: str, email: str, new_password: str, confirm_password: str) -> tuple[bool, str]:
+    """
+    Réinitialise le mot de passe d'un utilisateur final (End User) lié à un client donné.
+    """
+    if new_password != confirm_password:
+        return False, "Les mots de passe ne correspondent pas."
+    if len(new_password) < 8:
+        return False, "Le nouveau mot de passe est trop court (min 8 caractères)."
+
+    user_data_list = load_primary_user_data(
+        filters={
+            FIELD_EMAIL: email,
+            FIELD_USER_TYPE: 'End',
+            FIELD_CLIENT_ID: client_id
+        }
+    )
+    
+    if not user_data_list:
+        return False, "Utilisateur non trouvé." 
+    
+    user_data = user_data_list[0]
+    
+    # Mise à jour du mot de passe
+    user_data[FIELD_PASSWORD_HASH] = generate_password_hash(new_password)
+    
+    baserow_row_id = user_data.get('baserow_row_id')
+    
+    if baserow_row_id is None:
+        return False, "Erreur de configuration: ID de ligne Baserow manquant."
+        
+    success, _ = save_primary_user_data(user_data, commit_to_baserow=True)
+    
+    if success:
+        return True, "Votre mot de passe a été réinitialisé avec succès."
+    else:
+        return False, "Une erreur s'est produite lors de la réinitialisation du mot de passe."
+
+def get_client_user_by_uuid(user_uuid: str) -> Optional[Dict]:
+    """
+    Récupère les données d'un utilisateur principal (Client) par son UUID/ID.
+    
+    Ceci est un alias pour satisfaire l'appel de fonction dans decorators.py
+    sans avoir à modifier ce dernier fichier.
+    
+    Elle suppose que la fonction 'get_user_by_id' est déjà définie 
+    dans ce module et gère la logique de récupération de données.
+    """
+    # Assurez-vous que get_user_by_id est bien définie avant cet alias.
+    # get_user_by_id doit retourner les données utilisateur ou None.
+    return get_user_by_id(user_uuid)

a6ea61c8-951a-413a-ba9d-7365d83fbd4d/mayproject/baserow_storage.py

@@ -0,0 +1,791 @@
+# baserow_storage.py (Version Modifiée)
+
+import os
+import requests
+import json
+import sys
+from datetime import datetime
+from typing import Optional, Dict
+import logging
+# Configuration du logger (ajoutez ceci en haut du fichier)
+logger = logging.getLogger(__name__)
+# --- Configuration Baserow (Doit être défini dans les secrets) ---
+HEALTH_CHECK_URL = "https://api.baserow.io/api/database/rows/table/"
+
+# 2. URL de BASE CORRECTE pour la construction des requêtes de données (connexion, inscription, etc.)
+DATA_BASE_URL = "https://api.baserow.io/api/database/rows/"
+API_TOKEN = os.environ.get("BASEROW_API_TOKEN")
+
+# Les IDs de table seront récupérés depuis les variables d'environnement
+PRIMARY_USERS_TABLE_ID = os.environ.get("PRIMARY_USERS_TABLE_ID") 
+END_USERS_TABLE_ID = os.environ.get("END_USERS_TABLE_ID") 
+# NOUVEL ID DE TABLE POUR LES DÉPLOIEMENTS (Projets)
+DEPLOYMENTS_TABLE_ID = os.environ.get("DEPLOYMENTS_TABLE_ID")
+
+# Headers pour l'authentification
+HEADERS = {
+    "Authorization": f"Token {API_TOKEN}",
+    "Content-Type": "application/json"
+}
+
+
+FIELD_ID = 'ID' # Correspond à 'user_id' dans le code
+FIELD_EMAIL = 'Email' # Correspond à 'email'
+FIELD_USERNAME = 'Nom d\'utilisateur' # Correspond à 'username'
+FIELD_PASSWORD_HASH = 'Hachage Mot de Passe' # Correspond à 'password_hash'
+FIELD_API_KEY = 'Clé API' # Correspond à 'api_key'
+FIELD_API_KEY_2 = 'Clé API 2'
+FIELD_API_KEY_3 = 'Clé API 3'
+FIELD_API_KEY_4 = 'Clé API 4'
+FIELD_API_KEY_5 = 'Clé API 5'
+FIELD_SECURITY_Q = 'Question de Sécurité'
+FIELD_SECURITY_A_HASH = 'Hachage Réponse Secrète'
+FIELD_PLAN_ID = 'Plan ID'
+FIELD_STRIPE_SUB_ID = 'ID Abonnement Stripe'
+FIELD_DATE_CREATION = 'Date Création'
+FIELD_DATE_PLAN_START = 'Date Plan Start'
+FIELD_API_CALLS_MONTH = 'API Calls Month' # À vérifier avec votre nom exact dans Baserow!
+FIELD_STATUS = 'Status'
+FIELD_END_USER_ID = 'ID Utilisateur Final' # Correspond à 'end_user_id'
+FIELD_END_USER_IDENTIFIER = 'Identifiant' # Correspond à 'identifier'
+FIELD_END_USER_METADATA = 'Métadonnées' # Correspond à 'metadata'
+FIELD_CLIENT_ID_LINK = 'ID Client Principal' # Lien vers Primary_Users
+FIELD_USER_TYPE = 'UserType' # Ex: 'Primary' pour les clients, 'End' pour leurs utilisateurs
+FIELD_CLIENT_ID = 'ClientID' # L'ID de l'utilisateur 'Primary' qui possède cet utilisateur 'End'
+
+# ----------------------------------------------------------------------
+# --- Noms de Colonnes pour la Table des Utilisateurs Finaux (End Users) ---
+# ----------------------------------------------------------------------
+# Ces champs sont spécifiques à la table END_USERS
+FIELD_END_USER_ID = 'ID Utilisateur Final'
+FIELD_END_USER_IDENTIFIER = 'Identifiant' # Champ pour compatibilité ou recherche
+FIELD_END_USER_EMAIL = 'Email' # NOUVEAU
+FIELD_END_USER_USERNAME = 'Nom d\'utilisateur' # NOUVEAU
+FIELD_END_USER_SECURITY_Q = 'Question de Sécurité' # NOUVEAU (Peut être différent de Primary)
+FIELD_END_USER_SECURITY_A_HASH = 'Hachage Réponse Secrète' # NOUVEAU
+FIELD_END_USER_STATUS = 'Statut' # NOUVEAU
+FIELD_END_USER_METADATA = 'Métadonnées' 
+FIELD_PASSWORD_HASH_END_USER = 'Hachage Mot de Passe End User' # Renommer pour éviter le conflit si possible
+FIELD_CLIENT_ID_LINK = 'ID Client Principal'
+
+def _get_table_url(table_id: str) -> str:
+    """Construit l'URL d'API pour une table donnée (avec le bon endpoint)."""
+    return f"{DATA_BASE_URL}table/{table_id}/"
+
+def _baserow_record_to_user(record: Dict, is_end_user: bool) -> Dict:
+    """
+    Convertit un enregistrement Baserow (avec noms de champs utilisateur)
+    en format de dictionnaire Python attendu par le backend.
+    """
+    
+
+        
+    # LOGIQUE POUR L'UTILISATEUR PRINCIPAL (PRIMARY USER)
+    
+    # 1. Récupération des champs individuels
+    user_data = {
+        # Champs communs / Primary Users
+        'baserow_row_id': record['id'], # ID interne de la ligne Baserow (pour les mises à jour)
+        'date_creation': record.get(FIELD_DATE_CREATION),
+        
+        # Primary User specific fields
+        'user_id': record.get(FIELD_ID),
+        'email': record.get(FIELD_EMAIL),
+        'username': record.get(FIELD_USERNAME),
+        'password_hash': record.get(FIELD_PASSWORD_HASH),
+        
+        # Récupération des 5 clés individuelles (pour l'authentification par clé)
+        'api_key': record.get(FIELD_API_KEY),
+        'api_key_2': record.get(FIELD_API_KEY_2),
+        'api_key_3': record.get(FIELD_API_KEY_3),
+        'api_key_4': record.get(FIELD_API_KEY_4),
+        'api_key_5': record.get(FIELD_API_KEY_5),
+        
+        'security_question': record.get(FIELD_SECURITY_Q),
+        'security_answer_hash': record.get(FIELD_SECURITY_A_HASH),
+        'plan_id': record.get(FIELD_PLAN_ID),
+        'stripe_subscription_id': record.get(FIELD_STRIPE_SUB_ID),
+        'date_plan_start': record.get(FIELD_DATE_PLAN_START),
+    }
+
+    # 2. ÉTAPE CRUCIALE AJOUTÉE : Création de la liste 'api_keys' pour l'affichage
+    # Cette liste est nécessaire pour que la boucle dans api_key.html fonctionne correctement.
+    user_data['api_keys'] = [
+        user_data['api_key'],
+        user_data['api_key_2'],
+        user_data['api_key_3'],
+        user_data['api_key_4'],
+        user_data['api_key_5'],
+    ]
+    
+    # Nettoyage des clés None ou non-pertinentes
+    return {k: v for k, v in user_data.items() if v is not None}
+
+
+def _user_to_baserow_data(user_data: Dict, is_end_user: bool) -> Dict:
+    """
+    Convertit le format de dictionnaire Python du backend en format
+    JSON attendu par l'API Baserow (avec noms de champs utilisateur).
+    """
+    if is_end_user:
+        # End User fields (Ajout des NOUVEAUX champs)
+        baserow_data = {
+            FIELD_END_USER_ID: user_data.get('end_user_id'),
+            FIELD_END_USER_IDENTIFIER: user_data.get('identifier'),
+            FIELD_END_USER_EMAIL: user_data.get('email'), # NOUVEAU
+            FIELD_END_USER_USERNAME: user_data.get('username'), # NOUVEAU
+            FIELD_END_USER_SECURITY_Q: user_data.get('security_question'), # NOUVEAU
+            FIELD_END_USER_SECURITY_A_HASH: user_data.get('security_answer_hash'), # NOUVEAU
+            FIELD_END_USER_STATUS: user_data.get('status'), # NOUVEAU
+            
+            # CORRECTION CRUCIALE : Utilisation du nom de champ correct pour l'End User
+            FIELD_PASSWORD_HASH_END_USER: user_data.get('password_hash'), 
+            
+            FIELD_END_USER_METADATA: user_data.get('metadata'),
+            FIELD_DATE_CREATION: user_data.get('date_creation'),
+            # Le lien vers Primary_Users est géré dans save_end_user_data
+        }
+    else:
+        # Primary User fields
+        baserow_data = {
+            FIELD_ID: user_data.get('user_id'),
+            FIELD_EMAIL: user_data.get('email'),
+            FIELD_USERNAME: user_data.get('username'),
+            FIELD_PASSWORD_HASH: user_data.get('password_hash'),
+            FIELD_API_KEY: user_data.get('api_key'),
+            FIELD_API_KEY_2: user_data.get('api_key_2'),
+            FIELD_API_KEY_3: user_data.get('api_key_3'),
+            FIELD_API_KEY_4: user_data.get('api_key_4'),
+            FIELD_API_KEY_5: user_data.get('api_key_5'),
+            FIELD_SECURITY_Q: user_data.get('security_question'),
+            FIELD_SECURITY_A_HASH: user_data.get('security_answer_hash'),
+            FIELD_PLAN_ID: user_data.get('plan_id'),
+            FIELD_STRIPE_SUB_ID: user_data.get('stripe_subscription_id'),
+            FIELD_DATE_CREATION: user_data.get('date_creation'),
+            FIELD_DATE_PLAN_START: user_data.get('date_plan_start'),
+            FIELD_API_CALLS_MONTH: user_data.get('api_calls_month', 0),
+            FIELD_STATUS: user_data.get('status', 'Active') # Assurez-vous que 'Active' est une option valide dans Baserow
+        }
+
+    # Suppression des clés non-valorisées (None)
+    return {k: v for k, v in baserow_data.items() if v is not None}
+
+
+def _get_single_user_record(table_id: str, field_name: str, value: str, is_end_user: bool) -> Optional[Dict]:
+    """Fonction générique pour rechercher un seul enregistrement par un champ (filtrage Baserow)."""
+    url = _get_table_url(table_id)
+    # Utilisation du paramètre de filtre de Baserow pour une recherche indexée (plus rapide)
+    filter_param = f"filter__{field_name}__equal={value}"
+    
+    try:
+        response = requests.get(
+            f"{url}?user_field_names=true&{filter_param}",
+            headers=HEADERS
+        )
+        response.raise_for_status()
+        
+        data = response.json()
+        if data and data.get('results'):
+            # On ne prend que le premier résultat (car ID/Email/API Key sont uniques)
+            return _baserow_record_to_user(data['results'][0], is_end_user)
+        return None
+        
+    except requests.exceptions.RequestException as e:
+        print(f"Erreur de Baserow lors de la recherche par filtre {field_name}: {e}", file=sys.stderr)
+        return None
+
+# ----------------------------------------------------------------------
+# --- Fonctions CRUD Primary_Users (Nouveau et Remplacement) ---
+# ----------------------------------------------------------------------
+
+def get_user_by_email(email: str) -> Optional[Dict]:
+    """Recherche un utilisateur principal par son adresse Email."""
+    return _get_single_user_record(PRIMARY_USERS_TABLE_ID, FIELD_EMAIL, email, is_end_user=False)
+
+API_KEY_FIELDS = [
+    FIELD_API_KEY,  # Clé API
+    FIELD_API_KEY_2,
+    FIELD_API_KEY_3,
+    FIELD_API_KEY_4,
+    FIELD_API_KEY_5,
+]
+
+# baserow_storage.py - à partir de la ligne ~180 (ou autour de la fonction get_client_user_by_api_key)
+
+def get_client_user_by_api_key(api_key: str) -> Optional[Dict]:
+    """
+    Recherche un utilisateur principal dans Baserow en vérifiant la clé API
+    dans chacun des cinq champs de clé API de la table.
+    """
+    if not api_key:
+        logger.debug("get_client_user_by_api_key: Clé API est None ou vide.")
+        return None
+
+    # Construction de l'URL de base pour la table
+    url = f"{DATA_BASE_URL}table/{PRIMARY_USERS_TABLE_ID}/"
+    
+    # Recherche large dans la table (jusqu'à 100 lignes)
+    # NOTE: L'API Baserow utilise `search` pour une recherche FULL TEXT dans tous les champs.
+    # C'est la source potentielle de l'inexactitude qui nécessite un filtrage manuel.
+    params = {'search': api_key, 'size': 100} 
+    
+    try:
+        # CORRECTION 1: Utilisation de la fonction _make_baserow_request
+        # (Cette fonction est maintenant définie à la fin du fichier)
+        # On utilise log_response=True ici pour avoir un log détaillé si la requête échoue
+        response = _make_baserow_request("GET", url, params=params, log_response=True)
+        
+        if response.status_code == 200:
+            data = response.json()
+            
+            # NOUVEAU LOG : Afficher combien de résultats ont été renvoyés par la recherche Baserow
+            num_results = len(data.get('results', []))
+            logger.info(f"BASEROW SEARCH: Clé API: {api_key[:8]}... | URL: {url} | Résultats Baserow: {num_results}")
+            
+            if data and 'results' in data and num_results > 0:
+                # Filtrage manuel des résultats pour vérifier la clé exacte
+                for row in data['results']:
+                    # Vérifier si la clé API correspond à l'un des 5 champs
+                    if any(row.get(field) == api_key for field in API_KEY_FIELDS):
+                        # NOUVEAU LOG : SUCCÈS - L'utilisateur a été trouvé
+                        logger.info(f"BASEROW SUCCESS: Utilisateur trouvé avec la clé API {api_key[:8]}... dans un des 5 champs.")
+                        try:
+                            # On suppose que _baserow_record_to_user existe et prend un booléen
+                            return _baserow_record_to_user(row, is_end_user=False)
+                        except NameError:
+                            logger.error("_baserow_record_to_user non définie. Erreur critique.")
+                            return None
+                
+                # NOUVEAU LOG : ÉCHEC DU FILTRAGE
+                logger.warning(f"BASEROW FILTER FAIL: {num_results} ligne(s) trouvée(s) par 'search' Baserow, mais aucune ne correspondait exactement à la clé API: {api_key[:8]}...")
+                return None 
+            
+            # Aucune ligne trouvée dans Baserow (num_results est 0)
+            logger.debug(f"BASEROW NO RESULT: Aucune ligne trouvée par la recherche Baserow pour la clé API: {api_key[:8]}...")
+            return None 
+
+        # Traiter les erreurs HTTP de Baserow (log déjà dans _make_baserow_request)
+        return None
+        
+    except Exception as e:
+        # Erreur inattendue pendant le traitement
+        logger.error(f"Erreur CRITIQUE lors du traitement de la recherche par clé API: {e}", exc_info=True)
+        return None
+
+# Remplacement de l'ancien load_primary_user_data(user_id)
+def load_primary_user_data(user_id: str) -> Optional[Dict]:
+    """Recherche un utilisateur principal par son ID (user_id)."""
+    return _get_single_user_record(PRIMARY_USERS_TABLE_ID, FIELD_ID, user_id, is_end_user=False)
+
+
+def save_primary_user_data(user_data: Dict, commit_msg: str = "") -> bool:
+    """Crée ou met à jour un utilisateur principal, avec détection d'erreur ultra-précise."""
+    row_id = user_data.get('baserow_row_id')
+    
+    # Définition de l'URL de base pour la table des utilisateurs principaux
+    url = _get_table_url(PRIMARY_USERS_TABLE_ID)
+    
+    # 1. Conversion des données
+    baserow_data = _user_to_baserow_data(user_data, is_end_user=False)
+    
+    # 2. Suppression des champs en lecture seule (comme dans la correction précédente)
+    if baserow_data.pop(FIELD_ID, None):
+        print(f"DEBUG: Suppression du champ '{FIELD_ID}' (UUID auto) avant l'envoi { 'POST' if not row_id else 'PATCH'}.", file=sys.stderr)
+    
+    try:
+        # Détermination de l'action (PATCH ou POST)
+        if row_id:
+            action = "PATCH" # ⬅️ CORRECTION: Définition de 'action'
+            # MISE À JOUR (PATCH)
+            response = requests.patch(
+                f"{url}{row_id}/?user_field_names=true",
+                headers=HEADERS, 
+                json=baserow_data
+            )
+        else:
+            action = "POST" # ⬅️ CORRECTION: Définition de 'action'
+            # CRÉATION (POST)
+            response = requests.post(
+                f"{url}?user_field_names=true", # ⬅️ CORRECTION: Utilise l'URL de table 'url'
+                headers=HEADERS, 
+                json=baserow_data
+            )
+        
+        # Déclenche une exception requests.exceptions.HTTPError pour les statuts 4xx/5xx
+        response.raise_for_status() 
+        
+        # Succès
+        if not row_id:
+            new_record = response.json()
+            # 1. Mettre à jour l'ID de ligne Baserow
+            user_data['baserow_row_id'] = new_record.get('id')
+            # 2. Mettre à jour l'UUID de l'utilisateur (généré par Baserow)
+            user_data['user_id'] = new_record.get(FIELD_ID) 
+            
+            print(f"DEBUG: UUID de l'utilisateur généré par Baserow et enregistré: {user_data['user_id']}", file=sys.stderr)
+            
+        print(f"DEBUG: Baserow Primary User action '{action}' réussie. Row ID: {user_data.get('baserow_row_id')}. Message: {commit_msg}", file=sys.stderr)
+        return True
+        
+    except requests.exceptions.RequestException as e:
+        # --- BLOC DE DÉTECTION D'ERREUR PRÉCISE (Ultra-Complet) ---
+        
+        # Note: 'action' est définie dans le bloc try/except, mais si l'erreur survient 
+        # AVANT la définition de 'action', nous devons la gérer. 
+        # Pour être sûr, nous allons la définir ici par défaut si elle n'existe pas.
+        if 'action' not in locals():
+            action = "INCONNU"
+            
+        error_message = f"🚨 ÉCHEC: Erreur lors de la sauvegarde/mise à jour du Primary User dans Baserow. Requête: {action}"
+        error_details = ""
+
+        if hasattr(e, 'response') and e.response is not None:
+            # 1. Statut HTTP et URL
+            error_details += f"\n  -> STATUT HTTP: {e.response.status_code} ({e.response.reason})"
+            error_details += f"\n  -> URL de la requête: {e.response.url}"
+            
+            # 2. Tenter de décoder le corps de la réponse en JSON (contient les erreurs Baserow)
+            try:
+                response_json = e.response.json()
+                error_details += f"\n\n  -> ERREUR BASEROW DÉTAILLÉE (JSON):\n{json.dumps(response_json, indent=4)}"
+                
+                # Optionnel: Synthèse des erreurs de validation de champ
+                if isinstance(response_json, dict):
+                    validation_errors = {k: v for k, v in response_json.items() if isinstance(v, list) and k != 'detail'}
+                    if validation_errors:
+                        error_details += "\n  -> SYNTHÈSE DES CHAMPS INVALIDES (Vérifiez les noms de colonnes/IDs de table!):"
+                        for field_name, errors in validation_errors.items():
+                             error_details += f"\n    - Champ '{field_name}': {', '.join([err.get('error', 'Erreur inconnue') for err in errors])}"
+                    
+            except json.JSONDecodeError:
+                # 3. Si le corps de la réponse n'est pas du JSON
+                error_details += f"\n\n  -> ERREUR BRUTE (Réponse non-JSON):\n{e.response.text[:500]}..."
+
+        # 4. Afficher les données que nous avons tenté d'envoyer (après la suppression de l'ID si c'était une création)
+        error_details += f"\n\n  -> DONNÉES ENVOYÉES À BASEROW:\n{json.dumps(baserow_data, indent=4)}"
+        
+        # Log complet de l'erreur
+        print(error_message + error_details, file=sys.stderr)
+        
+        return False
+        
+        
+# ----------------------------------------------------------------------
+# --- Fonctions CRUD End_Users (Remplacement) ---
+# ----------------------------------------------------------------------
+
+# baserow_storage.py : Dans la section CRUD End_Users
+
+
+def _get_client_baserow_row_id(client_user_id: str) -> Optional[int]:
+    """Récupère l'ID de ligne interne Baserow du client principal pour le lien."""
+    client_user = load_primary_user_data(client_user_id) # utilise la fonction déjà créée
+    return client_user.get('baserow_row_id') if client_user else None
+
+
+def check_baserow_connection() -> str:
+    """
+    Vérifie l'état de connexion de la base de données Baserow.
+    Retourne 'operational' ou 'outage'.
+    """
+    # Liste des IDs de tables critiques à vérifier
+    CRITICAL_TABLE_IDS = [
+        PRIMARY_USERS_TABLE_ID, 
+        END_USERS_TABLE_ID
+    ]
+    
+    if not API_TOKEN:
+        # Si le token API n'est pas défini, échec immédiat
+        print("DEBUG: BASEROW_API_TOKEN manquant.", file=sys.stderr)
+        return "outage" 
+
+    for table_id in CRITICAL_TABLE_IDS:
+        if not table_id:
+            # Si un des IDs de table critiques n'est pas défini, échec
+            print(f"DEBUG: Un ID de table critique Baserow est manquant (ID: {table_id}).", file=sys.stderr)
+            return "outage"
+
+        # Tenter de faire un appel très léger (récupérer la première ligne)
+        # On utilise page_size=1 pour minimiser la charge
+        url = f"{DATA_BASE_URL}table/{table_id}/?page_size=1"
+        
+        try:
+            response = requests.get(url, headers=HEADERS, timeout=5)
+            
+            if response.status_code != 200:
+                # Si un 404, 403, ou autre erreur est retournée par Baserow pour CETTE table
+                print(f"DEBUG: Baserow check failed for table {table_id} with status code {response.status_code}", file=sys.stderr)
+                return "outage"
+                
+        except requests.exceptions.RequestException as e:
+            # Erreur de réseau (timeout, DNS, etc.)
+            print(f"DEBUG: Baserow connection error for table {table_id}: {e}", file=sys.stderr)
+            return "outage"
+            
+    # Si toutes les tables critiques ont été vérifiées avec succès
+    return "operational"
+
+
+def get_health_status() -> Dict:
+    """
+    Collecte l'état de santé de tous les services pour la page /statut.
+    """
+    
+    db_status = check_baserow_connection()
+    
+    # L'état de l'authentification et de l'API principale sont 
+    # généralement liés à l'état de la DB pour une application simple.
+    # Si la DB est HS, l'auth est HS. Sinon, ils sont OK.
+    
+    auth_status = db_status # Lié à la DB (pour charger les utilisateurs)
+    api_endpoint_status = "operational" # L'endpoint Flask lui-même est considéré comme OK s'il tourne
+    
+    # Version du service (pour information)
+    service_version = os.environ.get("SERVICE_VERSION", "1.0.0 (Baserow)")
+
+
+    return {
+        # Ces valeurs correspondent aux attributs 'data-status' dans statut.html
+        "auth": auth_status, 
+        "data_storage": db_status, 
+        "api_endpoint": api_endpoint_status,
+        "version": service_version,
+        "last_update": datetime.now().strftime("%Y-%m-%d %H:%M:%S UTC")
+    }
+
+def is_baserow_up() -> bool:
+    """
+    Vérifie l'état de Baserow en utilisant l'URL qui garantit un statut 100% fonctionnel
+    sur Hugging Face, SANS utiliser la fonction de construction d'URL de table.
+    """
+    try:
+        # Envoie une requête GET à l'URL qui répond positivement pour le health check.
+        response = requests.get(
+            HEALTH_CHECK_URL,
+            headers=HEADERS,
+            timeout=5
+        )
+        # On vérifie si la réponse est un succès (code 200).
+        return response.status_code == 200
+    except requests.exceptions.RequestException as e:
+        print(f"DEBUG: Baserow health check failed: {e}")
+        return False
+
+def _make_baserow_request(method: str, url: str, params: Optional[Dict] = None, data: Optional[Dict] = None, log_response: bool = True):
+    """
+    Fonction utilitaire pour effectuer des appels API à Baserow et journaliser 
+    les requêtes et les réponses dans les logs du Space Hugging Face.
+    """
+    # 1. Journalisation de la requête
+    logger.info(f"BASEROW REQUEST: {method} {url}")
+    # ATTENTION: Ne pas logger le token API complet!
+    logged_headers = {k: v.replace(API_TOKEN, '[TOKEN_MASKED]') if k == 'Authorization' else v for k, v in HEADERS.items()}
+    logger.debug(f"BASEROW REQUEST Headers: {logged_headers}")
+    if data:
+        # Pour les requêtes POST/PUT, logger les données (sans le hash du mot de passe si possible)
+        logged_data = data.copy() if isinstance(data, dict) else data
+        # 'Hachage Mot de Passe' est le nom du champ dans _user_to_baserow_data
+        if isinstance(logged_data, dict) and FIELD_PASSWORD_HASH in logged_data: 
+             logged_data[FIELD_PASSWORD_HASH] = '[PASSWORD_HASH_MASKED]'
+        # Le nom du champ n'était pas le même dans l'ancienne version, on utilise la constante
+        if isinstance(logged_data, dict) and 'Hachage du mot de passe' in logged_data:
+             logged_data['Hachage du mot de passe'] = '[PASSWORD_HASH_MASKED]'
+        logger.debug(f"BASEROW REQUEST Body: {logged_data}")
+    
+    # 2. Exécution de la requête
+    try:
+        # NOTE IMPORTANTE: Utilisation des HEADERS globaux et des 'params' pour GET
+        if method == "GET":
+            response = requests.get(url, headers=HEADERS, params=params)
+        elif method == "POST":
+            response = requests.post(url, headers=HEADERS, json=data)
+        elif method == "PUT":
+            response = requests.put(url, headers=HEADERS, json=data)
+        elif method == "DELETE":
+            response = requests.delete(url, headers=HEADERS)
+        elif method == "PATCH": # Ajout de la méthode PATCH pour la complétude
+            response = requests.patch(url, headers=HEADERS, json=data)
+        else:
+            raise ValueError(f"Méthode HTTP non supportée: {method}")
+        
+        # 3. Journalisation de la réponse
+        if log_response:
+            logger.info(f"BASEROW RESPONSE: Status {response.status_code}")
+            # Journaliser le contenu pour les erreurs
+            if response.status_code >= 400:
+                logger.error(f"BASEROW ERROR RESPONSE Body: {response.text}")
+                
+        # 4. Retourner la réponse
+        return response
+        
+    except requests.exceptions.RequestException as e:
+        logger.error(f"BASEROW CONNECTION ERROR: {e}")
+        # Retourne un objet Response factice pour l'utiliser dans la fonction appelante
+        return requests.Response()
+
+# --- NOUVELLES FONCTIONS POUR LES DÉPLOIEMENTS (Projets) ---
+
+
+
+def update_user_deployment_data(
+    user_baserow_row_id: int, 
+    deploy_id: str, 
+    user_link: str, # Utilisera l'ID interne de l'utilisateur
+    hf_repo_path: str
+) -> tuple[bool, str]:
+    """
+    Met à jour la ligne de l'utilisateur principal (PRIMARY_USERS_TABLE_ID) 
+    avec les données de déploiement du projet (ID, Repo, etc.).
+    """
+    if not PRIMARY_USERS_TABLE_ID:
+        return False, "Erreur de configuration: ID de la table utilisateur principal manquant."
+
+    url = f"{DATA_BASE_URL}table/{PRIMARY_USERS_TABLE_ID}/{user_baserow_row_id}/"
+    
+    # Les données à mettre à jour
+    data = {
+        FIELD_DEPLOY_ID: deploy_id,
+        FIELD_USER_REF: user_link,
+        FIELD_HF_REPO_PATH: hf_repo_path
+    }
+
+    # Utiliser PATCH pour mettre à jour seulement les champs spécifiés
+    response = _baserow_request(url, method="PATCH", data=data)
+    
+    if response.status_code == 200:
+        logger.info(f"Déploiement ID {deploy_id} enregistré sur l'utilisateur Row ID {user_baserow_row_id}.")
+        return True, "Données de déploiement enregistrées avec succès sur le compte utilisateur."
+    else:
+        logger.error(f"Échec de la mise à jour du déploiement Baserow pour l'utilisateur {user_baserow_row_id}. Status: {response.status_code}, Body: {response.text}")
+        return False, f"Échec de la mise à jour Baserow: {response.status_code}"
+
+
+# ----------------------------------------------------------------------
+# --- MODIFICATION DE FONCTION : Récupérer le déploiement par ID ---
+# La recherche doit maintenant se faire dans la table utilisateur.
+# ----------------------------------------------------------------------
+def get_deployment_by_id(deploy_id: str) -> Optional[Dict]:
+    """
+    Récupère les détails du déploiement (la ligne de l'utilisateur) par son ID unique (le nom du dossier HF).
+    """
+    if not PRIMARY_USERS_TABLE_ID:
+        return None
+        
+    # Utiliser un filtre Baserow pour chercher par l'ID de déploiement dans la table utilisateur
+    url = f"{DATA_BASE_URL}table/{PRIMARY_USERS_TABLE_ID}/"
+    
+    # Construction du filtre Baserow: filter__Deployment ID__equal={deploy_id}
+    filter_param = f"filter__{FIELD_DEPLOY_ID}__equal"
+    params = {
+        filter_param: deploy_id
+    }
+    
+    response = _baserow_request(url, method="GET", params=params)
+    
+    if response.status_code == 200:
+        results = response.json().get('results', [])
+        if results:
+            # Retourne les données de l'utilisateur contenant les données de déploiement
+            # Notez que cela renvoie la ligne utilisateur complète.
+            return results[0] 
+        else:
+            return None
+    else:
+        logger.error(f"Échec de la récupération du déploiement Baserow. Status: {response.status_code}, Body: {response.text}")
+        return None
+
+def save_new_repository(
+    user_id: int, 
+    repo_data: Dict
+) -> tuple[bool, str]:
+    """
+    Ajoute un nouveau dépôt à la liste 'FIELD_REPOS_DATA' de l'utilisateur.
+    Ceci remplace l'ancienne approche 'save_new_deployment' qui supposait un seul déploiement par utilisateur.
+    """
+    
+    user_record = load_primary_user_data(filters={FIELD_ID: user_id}, single_record=True)
+    if not user_record:
+        logger.error(f"Utilisateur ID '{user_id}' non trouvé pour l'enregistrement du dépôt.")
+        return False, "Utilisateur non trouvé."
+
+    row_id = user_record.get('id')
+    if not row_id:
+        return False, f"Erreur critique: ID de ligne Baserow manquant pour l'utilisateur '{user_id}'."
+
+    # 1. Récupérer et désérialiser la liste des dépôts existants
+    repos_json = user_record.get(FIELD_REPOS_DATA)
+    try:
+        # Baserow renvoie 'None' ou une chaîne vide si le champ est vide
+        existing_repos = json.loads(repos_json) if repos_json and isinstance(repos_json, str) else []
+    except json.JSONDecodeError:
+        logger.warning(f"Champs Repositories Data corrompu pour l'utilisateur {user_id}. Réinitialisation.")
+        existing_repos = []
+
+    # 2. Ajouter le nouveau dépôt
+    existing_repos.append(repo_data)
+
+    # 3. Sérialiser la liste mise à jour
+    updated_repos_json = json.dumps(existing_repos)
+
+    # 4. Mettre à jour Baserow
+    url = f"{DATA_BASE_URL}table/{PRIMARY_USERS_TABLE_ID}/{row_id}/"
+    data = {
+        FIELD_REPOS_DATA: updated_repos_json
+    }
+
+    response = _make_baserow_request(
+        method="PATCH", 
+        url=url, 
+        data=data,
+        log_response=True
+    )
+
+    if response.status_code == 200:
+        logger.info(f"Nouveau dépôt '{repo_data['repo_name']}' enregistré pour l'utilisateur ID {user_id}.")
+        return True, "Dépôt enregistré avec succès."
+    else:
+        # Gérer l'échec de la mise à jour (ex: données trop volumineuses ou erreur API)
+        error_message = response.text
+        logger.error(f"Échec de l'enregistrement du dépôt pour l'utilisateur {user_id}: {error_message}")
+        return False, f"Échec de la mise à jour Baserow: {error_message}"
+
+# Nouvelle fonction pour récupérer la liste de tous les dépôts d'un utilisateur
+def get_all_user_repositories(user_id: int) -> list:
+    """Récupère tous les dépôts d'un utilisateur depuis le champ JSON."""
+    user_record = load_primary_user_data(filters={FIELD_ID: user_id}, single_record=True)
+    if not user_record:
+        return []
+        
+    repos_json = user_record.get(FIELD_REPOS_DATA)
+    try:
+        return json.loads(repos_json) if repos_json and isinstance(repos_json, str) else []
+    except json.JSONDecodeError:
+        logger.warning(f"Champs Repositories Data corrompu pour l'utilisateur {user_id}.")
+        return []
+
+
+def delete_deployment_by_id(deploy_id: str) -> tuple[bool, str]:
+    """
+    Supprime l'enregistrement d'un déploiement (la ligne utilisateur) 
+    dans la table PRIMARY_USERS_TABLE_ID par le Deployment ID.
+    
+    Note: Cela supprime la ligne utilisateur complète. Si la structure 
+    change (1 utilisateur -> plusieurs déploiements), cela devra être adapté.
+    Pour l'instant, on suppose 1 utilisateur = 1 ligne = 1 déploiement.
+    
+    Version modifiée pour mettre à NULL les champs de déploiement au lieu de supprimer la ligne utilisateur.
+    """
+    # 1. Récupérer l'enregistrement de l'utilisateur par l'ID de déploiement (le dossier HF)
+    user_record = get_deployment_by_id(deploy_id) 
+    
+    if not user_record:
+        logger.warning(f"Tentative de suppression de déploiement échouée: ID '{deploy_id}' non trouvé dans Baserow.")
+        return True, "Déploiement non trouvé dans Baserow (considéré comme déjà supprimé)."
+
+    # 2. Récupérer l'ID de ligne Baserow pour la mise à jour
+    row_id = user_record.get('id')
+    
+    if not row_id:
+        return False, f"Erreur critique: ID de ligne Baserow manquant pour le déploiement '{deploy_id}'."
+        
+    # 3. Mettre à jour les champs de déploiement à NULL (ou vide) au lieu de supprimer la ligne utilisateur
+    # Note: On suppose que la suppression de déploiement réinitialise ces champs.
+    url = f"{DATA_BASE_URL}table/{PRIMARY_USERS_TABLE_ID}/{row_id}/"
+    data = {
+        FIELD_DEPLOY_ID: None,
+        FIELD_USER_REF: None,
+        FIELD_HF_REPO_PATH: None
+    }
+    
+    response = _make_baserow_request(
+        method="PATCH", 
+        url=url, 
+        data=data,
+        log_response=True
+    )
+    
+    if response.status_code == 200:
+        logger.info(f"Déploiement ID {deploy_id} supprimé (champs mis à NULL) sur l'utilisateur Row ID {row_id}.")
+        return True, "Déploiement supprimé de la base de données avec succès."
+    else:
+        logger.error(f"Échec de la suppression du déploiement Baserow (PATCH à NULL) pour l'utilisateur Row ID {row_id}. Status: {response.status_code}, Body: {response.text}")
+        return False, f"Échec de la suppression Baserow: {response.status_code}"
+
+# baserow_storage.py - NOUVELLES FONCTIONS DE VÉRIFICATION DE CHAMPS
+
+# --- Liste des Champs Critiques pour la Table Primary Users (pour la vérification) ---
+# Ces champs sont nécessaires pour le fonctionnement global de l'app (Connexion, Profil, Déploiement)
+CRITICAL_PRIMARY_USER_FIELDS = [
+    # Primary User Fields (Fonctions Utilisateur)
+    FIELD_ID,
+    FIELD_EMAIL,
+    FIELD_USERNAME,
+    FIELD_PASSWORD_HASH,
+    FIELD_API_KEY,
+    FIELD_API_KEY_2,
+    FIELD_API_KEY_3,
+    FIELD_API_KEY_4,
+    FIELD_API_KEY_5,
+    FIELD_SECURITY_Q,
+    FIELD_SECURITY_A_HASH,
+    FIELD_PLAN_ID,
+    FIELD_STRIPE_SUB_ID,
+    FIELD_DATE_CREATION,
+    FIELD_DATE_PLAN_START,
+    FIELD_API_CALLS_MONTH,
+    FIELD_STATUS,
+]
+
+def _get_table_fields_url(table_id: str) -> str:
+    """Construit l'URL d'API pour lister les champs (colonnes) d'une table."""
+    # L'endpoint pour lister les champs est généralement /api/database/fields/table/{table_id}/
+    return f"https://api.baserow.io/api/database/fields/table/{table_id}/"
+
+def check_critical_fields_existence() -> str:
+    """
+    Vérifie que tous les champs critiques requis sont présents dans la table PRIMARY_USERS_TABLE_ID.
+    Retourne "operational" ou un message d'erreur listant les champs manquants.
+    """
+    if not API_TOKEN or not PRIMARY_USERS_TABLE_ID:
+        return "Configuration Baserow incomplète (Token ou ID de Table Manquant)."
+    
+    table_id = PRIMARY_USERS_TABLE_ID
+    url = _get_table_fields_url(table_id)
+    
+    try:
+        # Assurez-vous d'utiliser une fonction de requête qui gère l'authentification (e.g., _make_baserow_request si elle existe)
+        # Ici, nous utilisons directement requests pour un exemple clair.
+        response = requests.get(url, headers=HEADERS, timeout=10)
+        response.raise_for_status() # Lève une exception pour les codes d'erreur HTTP (4xx, 5xx)
+        
+        fields_data = response.json().get('results', [])
+        
+        # 1. Obtenir les noms des champs existants
+        existing_field_names = {field.get('name') for field in fields_data if 'name' in field}
+        
+        # 2. Identifier les champs manquants
+        missing_fields = [
+            field_name for field_name in CRITICAL_PRIMARY_USER_FIELDS 
+            if field_name not in existing_field_names
+        ]
+        
+        if missing_fields:
+            missing_str = ", ".join(missing_fields)
+            logger.error(f"Champs Baserow Manquants dans la table {table_id}: {missing_str}")
+            return f"CHAMPS BASEROW MANQUANTS: {missing_str}. Veuillez les créer."
+        
+        logger.info(f"SUCCÈS: Tous les {len(CRITICAL_PRIMARY_USER_FIELDS)} champs critiques Baserow sont trouvés.")
+        return "operational"
+
+    except requests.exceptions.HTTPError as e:
+        # Gérer l'erreur 404 si la table n'existe pas, ou 401/403 si le token est invalide
+        logger.error(f"Échec de l'API Baserow lors de la vérification des champs pour la table {table_id}: {e}")
+        return f"ÉCHEC API LORS DE LA VÉRIFICATION DES CHAMPS (Statut: {e.response.status_code}). Le token ou l'ID de table est probablement incorrect."
+    except requests.exceptions.RequestException as e:
+        logger.error(f"Erreur de connexion lors de la vérification des champs Baserow: {e}")
+        return f"ERREUR RÉSEAU/TIMEOUT lors de la vérification des champs Baserow: {e}"
+    except Exception as e:
+        logger.error(f"Erreur inattendue lors de la vérification des champs Baserow: {e}")
+        return f"ERREUR INATTENDUE: {e}"
+
+

a6ea61c8-951a-413a-ba9d-7365d83fbd4d/mayproject/billing_routes.py

@@ -0,0 +1,137 @@
+# billing_routes.py
+
+import os
+import stripe
+import json
+from flask import Blueprint, request, jsonify, Response, session, current_app, url_for
+from decorators import login_required 
+from auth_backend import get_user_by_id, get_plan_details, update_user_plan
+import traceback
+
+# Initialisation de Stripe avec la clé secrète
+# La clé sera lue depuis les variables d'environnement (secrets HF)
+stripe.api_key = os.environ.get("STRIPE_SECRET_KEY")
+
+# Création du Blueprint 'billing_bp'
+billing_bp = Blueprint('billing_bp', __name__)
+
+# --- Route API pour créer la session de paiement (Phase 3) ---
+@billing_bp.route("/api/create-checkout-session", methods=["POST"])
+@login_required
+def create_checkout_session():
+    """
+    Crée une session de checkout Stripe pour un plan donné.
+    """
+    data = request.get_json()
+    # Le plan_id doit être l'ID complet (ex: 'standard_monthly' ou 'illimited_annual')
+    final_plan_id = data.get('plan_id') 
+    user_id = session.get('user_id')
+    
+    plan_details = get_plan_details(final_plan_id)
+    
+    # Détermination de l'ID de prix Stripe (utilise monthly ou annual selon ce qui est défini)
+    price_id = plan_details.get('price_id_monthly') or plan_details.get('price_id_annual')
+
+    # Vérification de l'existence du plan et de l'ID de prix Stripe
+    if not plan_details or not price_id:
+        if final_plan_id == 'free':
+             return jsonify({"message": "Ce plan est gratuit, pas de session de paiement requise.", "url": url_for('user_bp.dashboard')}), 200
+        
+        # Logique de sécurité/erreur si l'ID de prix est manquant pour un plan payant
+        current_app.logger.error(f"Erreur: ID de prix Stripe manquant pour le plan {final_plan_id}.")
+        return jsonify({"message": "Erreur de configuration du plan.", "status": "Error"}), 500
+
+    try:
+        # Création de la session de paiement Stripe
+        checkout_session = stripe.checkout.Session.create(
+            # Type de paiement pour les abonnements récurrents
+            mode='subscription', 
+            # Les IDs de prix Stripe
+            line_items=[
+                {
+                    'price': price_id, 
+                    'quantity': 1
+                }
+            ],
+            # URLs de redirection après paiement/annulation
+            # _external=True est crucial pour que Stripe puisse rediriger correctement
+            success_url=url_for('user_bp.dashboard', payment='success', _external=True),
+            cancel_url=url_for('web_bp.checkout', plan=final_plan_id, payment='cancel', _external=True),
+            
+            # Informations personnalisées CRITIQUES pour le Webhook
+            metadata={
+                'user_id': user_id,
+                'plan_id': final_plan_id, # L'ID de plan complet (e.g. 'standard_monthly')
+            },
+            # Laisse Stripe pré-remplir l'email du client (si on le souhaite)
+            # customer_email=get_user_by_id(user_id).get('email'), 
+        )
+        
+        # Retourne l'URL de la session Stripe au frontend
+        return jsonify({'url': checkout_session.url}), 200
+
+    except stripe.error.StripeError as e:
+        current_app.logger.error(f"Erreur Stripe lors de la création de session: {e}")
+        return jsonify({"message": f"Une erreur Stripe est survenue: {e.user_message}", "status": "Error"}), 400
+    except Exception as e:
+        # Log toutes les autres erreurs pour le diagnostic
+        current_app.logger.error(f"Erreur inattendue lors de la création de session: {e}\n{traceback.format_exc()}")
+        return jsonify({"message": "Erreur interne du serveur lors de la création de la session.", "status": "Error"}), 500
+
+
+# --- Route Webhook Stripe (Phase 4) ---
+@billing_bp.route('/webhook/stripe', methods=['POST'])
+def stripe_webhook():
+    """
+    Gère les événements envoyés par Stripe pour mettre à jour l'abonnement de l'utilisateur.
+    """
+    payload = request.data
+    sig_header = request.headers.get('stripe-signature')
+    endpoint_secret = os.environ.get("STRIPE_WEBHOOK_SECRET")
+
+    # 1. Vérification que le secret est bien configuré
+    if not endpoint_secret:
+        current_app.logger.error("Erreur de configuration: STRIPE_WEBHOOK_SECRET est manquant.")
+        return jsonify({'message': 'Erreur de configuration serveur.'}), 500
+
+    try:
+        # 2. Validation de la signature du Webhook
+        event = stripe.Webhook.construct_event(
+            payload, sig_header, endpoint_secret
+        )
+    except Exception as e:
+        current_app.logger.error(f"Erreur Webhook Stripe (Validation): {e}")
+        # Retourne 400 pour que Stripe sache qu'il ne doit pas retenter cet événement
+        return 'Invalid payload or signature', 400
+
+    # 3. Traitement des événements
+    if event['type'] == 'checkout.session.completed':
+        session_data = event['data']['object']
+        
+        # Récupération des métadonnées CRITIQUES
+        user_id = session_data.get('metadata', {}).get('user_id')
+        plan_id = session_data.get('metadata', {}).get('plan_id') # L'ID de plan complet (e.g. 'standard_monthly')
+        subscription_id = session_data.get('subscription') # L'ID d'abonnement Stripe
+        
+        if user_id and plan_id and subscription_id:
+            # Appel à la fonction de mise à jour de la base de données (Phase 4)
+            success = update_user_plan(user_id, plan_id, subscription_id)
+            
+            if success:
+                current_app.logger.info(f"SUCCESS: Utilisateur {user_id} mis à jour au plan {plan_id} (Sub ID: {subscription_id})")
+            else:
+                # Le paiement a eu lieu, mais la BDD n'a pas été mise à jour: CRITIQUE
+                current_app.logger.error(f"FAILURE: Échec de la mise à jour Git pour l'utilisateur {user_id} après paiement Stripe. Plan: {plan_id}")
+        else:
+             # Manque d'infos critiques dans le webhook
+             current_app.logger.error(f"FAILURE: Données critiques manquantes dans le webhook. Session ID: {session_data.get('id')}. User ID: {user_id}. Plan ID: {plan_id}")
+             # Retourne 200 pour éviter une boucle de ré-envoi par Stripe
+             return jsonify({'message': 'Données utilisateur critiques manquantes dans la session Stripe.'}), 200 
+             
+    # Vous pouvez ajouter d'autres événements si nécessaire (ex: 'customer.subscription.deleted')
+    # elif event['type'] == 'customer.subscription.deleted':
+    #     current_app.logger.info(f"INFO: Abonnement Stripe supprimé. ID de souscription: {event['data']['object'].get('id')}")
+
+
+    # Retourne une réponse pour accuser réception de l'événement (très important)
+    return jsonify({'status': 'success'}), 200

a6ea61c8-951a-413a-ba9d-7365d83fbd4d/mayproject/config.py

@@ -0,0 +1,122 @@
+# config.py
+
+# Fichier de configuration pour le backend ErnestMind 2.5
+import os
+
+# --- Configuration Baserow (Nouveau) ---
+# Clés à définir dans les secrets d'environnement Hugging Face Space
+BASEROW_DATABASE_ID = os.environ.get("BASEROW_DATABASE_ID") 
+PRIMARY_USERS_TABLE_ID = os.environ.get("PRIMARY_USERS_TABLE_ID") 
+END_USERS_TABLE_ID = os.environ.get("END_USERS_TABLE_ID")
+# Le token d'accès API
+BASEROW_API_TOKEN = os.environ.get("BASEROW_API_TOKEN")
+
+# --- Configuration Stripe (Paiement) ---
+# Clés à définir dans les secrets d'environnement Hugging Face Space
+STRIPE_SECRET_KEY = os.environ.get("STRIPE_SECRET_KEY")
+STRIPE_WEBHOOK_SECRET = os.environ.get("STRIPE_WEBHOOK_SECRET")
+# Clé Publique (utilisée par le Frontend, mais stockée ici pour référence)
+STRIPE_PUBLIC_KEY = os.environ.get("STRIPE_PUBLIC_KEY")
+# --- Configuration Hugging Face (NOUVEAU: PRs) ---
+HF_DATASET_REPO_ID = os.environ.get("HF_DATASET_REPO_ID") # Déjà existant
+# NOUVELLE VARIABLE pour le dépôt des métadonnées de Pull Requests
+PULL_REQUESTS_HF_REPO_ID = os.environ.get("PULL_REQUESTS_HF_REPO_ID")
+# NOUVELLE VARIABLE pour le dépôt des métadonnées des Issues
+ISSUES_HF_REPO_ID = os.environ.get("ISSUES_HF_REPO_ID")
+GEMINI_API_KEY = os.environ.get("GEMINI_API_KEY")
+HF_TOKEN = os.environ.get("HF_TOKEN")
+GRMINI_HF_REPO_ID = os.environ.get("GEMINI_HF_REPO_ID")
+# ID du Dataset Hugging Face dédié au stockage d'images
+IMAGE_STORAGE_HF_REPO_ID = os.environ.get("IMAGE_STORAGE_HF_REPO_ID")
+# Les 'price_id' doivent correspondre aux IDs créés dans Stripe.
+PLANS_CONFIG = {
+    # Plan Gratuit
+    "free": {
+        "title": "Gratuit",
+        "baserow_value": "Free", # <--- NOUVEAU: Mettre la valeur EXACTE attendue par Baserow (ex: GRATUIT, Free, etc.)
+        "description": "Idéal pour les tests et les petits projets.",
+        "limit": 500,
+        "price_monthly": 0.0,
+        "price_annual": 0.0,
+        "price_id_monthly": None, 
+        "price_id_annual": None,  
+        "currency": "EUR"
+    },
+    # Plan Standard - Mensuel
+    "standard_monthly": {
+        "title": "Standard (Mensuel)",
+        "description": "Pour les utilisateurs réguliers. Paiement mensuel.",
+        "limit": 1000,
+        "price_monthly": 19.99,
+        "price_annual": 0.0,
+        "price_id_monthly": "price_1OvXXXXXXX", # REMPLACER PAR VOTRE VRAI ID STRIPE
+        "price_id_annual": None,
+        "currency": "EUR"
+    },
+    # Plan Standard - Annuel
+    "standard_annual": {
+        "title": "Standard (Annuel)",
+        "description": "Pour les utilisateurs réguliers. Économisez 20% en payant à l'année.",
+        "limit": 1000,
+        "price_monthly": 0.0,
+        "price_annual": 199.90, 
+        "price_id_monthly": None,
+        "price_id_annual": "price_1OwYYYYYYY", # REMPLACER PAR VOTRE VRAI ID STRIPE
+        "currency": "EUR"
+    },
+    # Plan Pro - Mensuel
+    "pro_monthly": {
+        "title": "Pro (Mensuel)",
+        "description": "Pour les professionnels et les projets importants. Paiement mensuel.",
+        "limit": 2000,
+        "price_monthly": 49.99,
+        "price_annual": 0.0,
+        "price_id_monthly": "price_1OxZZZZZZZ", # REMPLACER PAR VOTRE VRAI ID STRIPE
+        "price_id_annual": None,
+        "currency": "EUR"
+    },
+    # Plan Pro - Annuel
+    "pro_annual": {
+        "title": "Pro (Annuel)",
+        "description": "Pour les professionnels et les projets importants. Économisez 20% en payant à l'année.",
+        "limit": 2000,
+        "price_monthly": 0.0,
+        "price_annual": 499.90, 
+        "price_id_monthly": None,
+        "price_id_annual": "price_1OyAAAAAAA", # REMPLACER PAR VOTRE VRAI ID STRIPE
+        "currency": "EUR"
+    },
+    # Plan Illimité - Mensuel
+    "illimited_monthly": {
+        "title": "Illimité (Mensuel)",
+        "description": "Sans aucune restriction, pour les grandes entreprises. Paiement mensuel.",
+        "limit": float('inf'),
+        "price_monthly": 99.99,
+        "price_annual": 0.0,
+        "price_id_monthly": "price_1OzBBBBBBB", # REMPLACER PAR VOTRE VRAI ID STRIPE
+        "price_id_annual": None,
+        "currency": "EUR"
+    },
+    # Plan Illimité - Annuel
+    "illimited_annual": {
+        "title": "Illimité (Annuel)",
+        "description": "Sans aucune restriction, pour les grandes entreprises. Économisez 20% en payant à l'année.",
+        "limit": float('inf'),
+        "price_monthly": 0.0,
+        "price_annual": 999.90, 
+        "price_id_monthly": None,
+        "price_id_annual": "price_1OzAACCCCC", # REMPLACER PAR VOTRE VRAI ID STRIPE
+        "currency": "EUR"
+    },
+    # Plan Spécial pour les End-users (pas listé sur la page de prix)
+    "end_user": {
+        "title": "End-User",
+        "description": "Compte utilisateur créé par un client.",
+        "limit": 0,
+        "price_monthly": 0.0,
+        "price_annual": 0.0,
+        "price_id_monthly": None,
+        "price_id_annual": None,
+        "currency": "EUR"
+    },
+}

a6ea61c8-951a-413a-ba9d-7365d83fbd4d/mayproject/decorators.py

@@ -0,0 +1,87 @@
+# decorators.py
+
+from functools import wraps
+from flask import session, redirect, url_for, flash, request, jsonify
+
+# Import nécessaire pour le décorateur API 
+import auth_backend 
+
+def login_required(f):
+    @wraps(f)
+    def decorated_function(*args, **kwargs):
+        if session.get('user_id') is None:
+            flash("Vous devez être connecté pour accéder à cette page.", "error")
+            # REDIRECTION VERS LA NOUVELLE ROUTE DE CONNEXION DU BACKEND
+            return redirect(url_for('web_bp.connexion_page')) 
+        return f(*args, **kwargs)
+    return decorated_function
+
+def api_key_required(f):
+    """
+    Décorateur pour les routes d'API nécessitant une clé API valide (pour les clients externes).
+    ... (Reste inchangé)
+    """
+    @wraps(f)
+    def decorated_function(*args, **kwargs):
+        # 1. Récupérer la clé depuis l'en-tête ou les paramètres de requête
+        api_key = request.headers.get('X-API-Key')
+        if not api_key:
+            api_key = request.args.get('api_key') 
+
+        if not api_key:
+            return jsonify({
+                "message": "Authentification requise. Clé API manquante dans l'en-tête X-API-Key ou le paramètre api_key.", 
+                "status": "Unauthorized"
+            }), 401
+        
+        # 2. Valider la clé et récupérer l'utilisateur principal
+        client_user = auth_backend.get_client_user_by_api_key(api_key)
+
+        if not client_user:
+            return jsonify({
+                "message": "Clé API invalide ou non reconnue.", 
+                "status": "Forbidden"
+            }), 403
+            
+        # 3. Injecter les données de l'utilisateur principal (le client)
+        kwargs['client_user'] = client_user
+        
+        return f(*args, **kwargs)
+
+    return decorated_function
+
+# DÉCORATEUR : Pour les routes d'API qui doivent utiliser l'authentification par session
+def api_session_required(f):
+    """
+    Décorateur pour les routes d'API nécessitant une session utilisateur active (Web UI via session cookie).
+    Récupère l'ID utilisateur de la session et injecte les données de l'utilisateur dans la fonction.
+    """
+    @wraps(f)
+    def decorated_function(*args, **kwargs):
+        # 1. Récupérer l'ID utilisateur de la session
+        user_uuid = session.get('user_id')
+
+        if not user_uuid:
+            # Si l'ID est manquant, on renvoie une réponse JSON 401 (standard pour une API).
+            return jsonify({
+                "message": "Authentification par session requise. Utilisateur non connecté.", 
+                "status": "Unauthorized"
+            }), 401
+        
+        # 2. Récupérer l'utilisateur principal (client) à partir de son UUID
+        client_user = auth_backend.get_client_user_by_uuid(user_uuid)
+
+        if not client_user:
+            # L'utilisateur existe en session mais pas/plus dans la base.
+            session.pop('user_id', None) # Vider la session
+            return jsonify({
+                "message": "Session invalide ou utilisateur non reconnu.", 
+                "status": "Forbidden"
+            }), 403
+            
+        # 3. Injecter les données de l'utilisateur principal (le client)
+        kwargs['client_user'] = client_user
+        
+        return f(*args, **kwargs)
+
+    return decorated_function

a6ea61c8-951a-413a-ba9d-7365d83fbd4d/mayproject/deployment_routes.py

@@ -0,0 +1,149 @@
+# deployment_routes.py
+
+import logging
+from flask import Blueprint, request, jsonify
+from decorators import api_session_required, api_key_required
+from hf_deploy_manager import (
+    deploy_repo_to_space,
+    get_space_status,
+    fetch_space_logs,
+    stop_space,
+    get_public_space_url,
+)
+
+
+logger = logging.getLogger(__name__)
+
+# Création du Blueprint 'hf_deploy_bp'
+# Préfixe d'URL pour toutes les routes de ce Blueprint: /api/v1/deployment
+hf_deploy_bp = Blueprint('hf_deploy_bp', __name__, url_prefix='/api/v1/deployment')
+
+# --- Route 1 : Lancement du Déploiement (Création/Configuration du Space) ---
+
+
+@hf_deploy_bp.route("/<string:user_id>/<string:repo_slug>/deploy", methods=['POST'])
+@api_session_required # Assurez-vous que l'utilisateur est authentifié
+def deploy_project(user_id, repo_slug, client_user):
+    """
+    Lance le déploiement d'un dépôt utilisateur vers un nouveau Hugging Face Space.
+    Nécessite le 'sdk_type' (gradio, streamlit, docker, static) dans le corps JSON.
+    """
+    data = request.get_json()
+    sdk_type = data.get('sdk_type', 'gradio')
+    
+    # Validation minimale
+    if not user_id or not repo_slug:
+        return jsonify({"success": False, "message": "ID utilisateur ou slug de dépôt manquant dans l'URL."}), 400
+
+    logger.info(f"Déploiement initié pour le dépôt '{repo_slug}' (User: {user_id}, SDK: {sdk_type})")
+    
+    # Appel de la fonction de logique métier
+    result = deploy_repo_to_space(
+        user_id=user_id,
+        repo_slug=repo_slug,
+        sdk_type=sdk_type
+    )
+
+    if result.get("success"):
+        return jsonify(result), 200
+    else:
+        # Renvoie le message d'erreur et un code 500 ou 400 approprié
+        status_code = 500 if "erreur inattendue" in result.get("message", "").lower() else 400
+        return jsonify(result), status_code
+
+
+# --- Route 2 : Vérification du Statut du Space ---
+@hf_deploy_bp.route("/<path:space_id>/status", methods=['GET']) # Utiliser path pour autoriser le slash dans l'ID
+@api_session_required
+def get_deployment_status(space_id, client_user):
+    """
+    Récupère le statut (Running, Building, Error, etc.) d'un Space HF.
+    Le space_id DOIT être l'ID complet (ex: owner/repo-slug).
+    """
+    # L'ID complet (owner/repo_slug) est passé directement dans 'space_id'
+    if not space_id:
+        return jsonify({"success": False, "message": "L'ID complet du Space est manquant dans l'URL."}), 400
+
+    logger.debug(f"Demande de statut pour le Space: {space_id}")
+    result = get_space_status(space_id=space_id)
+
+    if result.get("success"):
+        return jsonify(result), 200
+    else:
+        return jsonify(result), 404 # 404 si le Space n'est pas trouvé
+
+
+# --- Route 3 : Récupération des Logs du Space ---
+@hf_deploy_bp.route("/<path:space_id>/logs", methods=['GET']) # Utiliser path pour autoriser le slash dans l'ID
+@api_session_required
+def get_deployment_logs(space_id, client_user):
+    """
+    Récupère les logs (build ou runtime) d'un Space HF.
+    """
+    # L'ID complet (owner/repo_slug) est passé directement dans 'space_id'
+    if not space_id:
+        return jsonify({"success": False, "message": "L'ID complet du Space est manquant dans l'URL."}), 400
+
+    logs_type = request.args.get('type', 'build') # Valeur par défaut: 'build'
+
+    logger.debug(f"Demande de logs de type '{logs_type}' pour le Space: {space_id}")
+    result = fetch_space_logs(space_id=space_id, logs_type=logs_type) # 'space_id' est l'ID complet
+
+    if result.get("success"):
+        return jsonify(result), 200
+    else:
+        return jsonify(result), 404
+
+
+# --- Route 4 : Arrêt (Mise en Pause) du Space ---
+@hf_deploy_bp.route("/<path:space_id>/stop", methods=['POST']) # Utiliser path pour autoriser le slash dans l'ID
+@api_session_required
+def stop_deployment(space_id, client_user):
+    """
+    Met en pause (Stop) un Space HF pour économiser des ressources.
+    """
+    # L'ID complet (owner/repo_slug) est passé directement dans 'space_id'
+    if not space_id:
+        return jsonify({"success": False, "message": "L'ID complet du Space est manquant dans l'URL."}), 400
+
+    logger.info(f"Arrêt demandé pour le Space: {space_id}")
+    result = stop_space(space_id=space_id) # 'space_id' est l'ID complet
+
+    if result.get("success"):
+        return jsonify(result), 200
+    else:
+        return jsonify(result), 400
+
+# --- Route 5 : Récupération de l'URL publique du Space ---
+@hf_deploy_bp.route("/<path:space_id>/url", methods=['GET']) # Utiliser path pour autoriser le slash dans l'ID
+@api_session_required
+def get_space_url(space_id, client_user):
+    """
+    Construit et retourne l'URL publique d'un Space HF à partir de son ID COMPLET ou du SLUG.
+    """
+    # L'ID complet (owner/repo_slug) est passé directement dans 'space_id'
+    if not space_id:
+        return jsonify({"success": False, "message": "L'ID complet du Space est manquant dans l'URL."}), 400
+
+    try:
+        # Extraire le SLUG du repo à partir de l'ID complet (owner/repo_slug)
+        # S'il y a un slash, on utilise la partie après, sinon on suppose que c'est déjà le slug
+        parts = space_id.split('/')
+        if len(parts) == 2:
+            space_id_slug = parts[1] # Cas 'owner/repo_slug'
+        elif len(parts) == 1:
+            space_id_slug = parts[0] # Cas où on reçoit seulement le 'repo_slug'
+        else:
+            raise ValueError("L'ID du Space doit être au format 'owner/repo_slug' ou juste le slug.")
+        
+        space_url = get_public_space_url(space_id_slug) # Utilise le SLUG pour l'URL publique
+        
+        return jsonify({
+            "success": True, 
+            "space_url": space_url,
+            "space_id": space_id # Retourne l'ID initial pour cohérence
+        }), 200
+        
+    except Exception as e:
+        logger.error(f"Erreur inattendue lors de la récupération de l'URL pour {space_id}: {e}")
+        return jsonify({"success": False, "message": f"Erreur lors de la construction de l'URL: {str(e)}"}), 500

a6ea61c8-951a-413a-ba9d-7365d83fbd4d/mayproject/entrypoint.sh

@@ -0,0 +1,24 @@
+#!/bin/bash
+# entrypoint.sh - Optimisé pour Gunicorn + Eventlet (SocketIO) sur Render
+
+# --- CONFIGURATION DES PERFORMANCES ---
+# ⚠️ POUR EVENTLET/SOCKETIO : Le nombre de workers doit être bas.
+# 1 worker est suffisant sur les plans de base de Render car Eventlet gère l'async.
+# Nous allons utiliser 1 worker.
+WORKERS=1 
+
+# --- PRÉPARATION ---
+
+echo "--- Démarrage de l'Application GitForge (Gunicorn/Eventlet) ---"
+
+# Définir le port par défaut de Render (la variable PORT est injectée par Render)
+export APP_PORT=${PORT:-8000} 
+
+# 1. Démarrer le serveur Flask/Gunicorn en premier plan
+echo "Démarrage du serveur Gunicorn sur le port $APP_PORT avec Eventlet et $WORKERS worker(s)..."
+
+# MODIFICATION MAJEURE: Utiliser le worker 'eventlet' pour supporter SocketIO (WebSockets)
+# -b 0.0.0.0:$APP_PORT: Se lie à l'interface publique fournie par Render.
+# --workers $WORKERS: Limite à un worker pour l'optimisation Eventlet.
+# app:app: Cible le module app.py et l'objet Flask nommé app.
+exec gunicorn --worker-class eventlet --workers $WORKERS app:app -b 0.0.0.0:$APP_PORT

a6ea61c8-951a-413a-ba9d-7365d83fbd4d/mayproject/gemini_functions.py

@@ -0,0 +1,462 @@
+# gemini_functions.py - Version étendue pour Hugging Face Data Management
+
+import os
+import logging
+import json
+import tempfile
+from typing import Generator, Dict, Optional, List
+import requests
+from flask import session 
+from datetime import datetime
+# NOUVEAU IMPORT pour gérer les fichiers uploadés par Flask
+from werkzeug.datastructures import FileStorage 
+import base64 # NOUVEAU IMPORT pour l'encodage Base64
+
+# --- IMPORT CORRIGÉ ET SPÉCIFIQUE DES VARIABLES DE CONFIGURATION ---
+from config import HF_TOKEN, GRMINI_HF_REPO_ID 
+# NOUVEAUX IMPORTS POUR HUGGING FACE
+from huggingface_hub import HfApi, HfFileSystem 
+
+
+logger = logging.getLogger(__name__)
+
+# --- Configuration du Backend Externe ---
+EXTERNAL_LLM_API_URL = "https://ernestmindres-ernestmind-llm-backend.hf.space/api/v1/generate_text"
+# NOUVEAU: URL pour le traitement multimodal
+EXTERNAL_LLM_FILES_API_URL = "https://ernestmindres-ernestmind-llm-backend.hf.space/api/v1/generate_text_with_files"
+
+# Utilisation de la variable GRMINI_HF_REPO_ID importée.
+GEMINI_HF_REPO_ID = GRMINI_HF_REPO_ID 
+# HF_TOKEN est maintenant disponible directement.
+HF_API_BASE = "https://huggingface.co/api" 
+
+# --- Fonctions Utilitaires ---
+def get_user_id_from_session() -> str:
+    """
+    Simule l'obtention de l'ID utilisateur à partir de la session Flask.
+    """
+    return session.get('user_id', 'TEST_USER_ID_FALLBACK') 
+
+def _get_conversation_file_path(user_id: str, conversation_id: str) -> str:
+    """Génère le chemin du fichier JSON dans le dépôt: <user_id>/<conversation_id>.json."""
+    return f"{user_id}/{conversation_id}.json"
+
+# ----------------------------------------------------------------------
+# FONCTIONS DE GESTION DU DATASET HUGGING FACE
+# ----------------------------------------------------------------------
+
+def load_conversation_history(user_id: str, conversation_id: str) -> List[Dict]:
+    """
+    Lit le contenu du fichier JSON de conversation dans le dataset Hugging Face en utilisant HfFileSystem.
+    """
+    file_path = _get_conversation_file_path(user_id, conversation_id)
+    
+    try:
+        # Initialiser le système de fichiers HF avec le jeton
+        fs = HfFileSystem(token=HF_TOKEN)
+        repo_path = f"datasets/{GEMINI_HF_REPO_ID}"
+        full_path = f"{repo_path}/{file_path}"
+        
+        if fs.exists(full_path):
+            # Ouvrir et lire le fichier depuis le dépôt
+            with fs.open(full_path, 'r', encoding='utf-8') as f:
+                logger.info(f"Historique de conversation {conversation_id} chargé avec succès.")
+                return json.load(f)
+        else:
+            # Fichier non trouvé (nouvelle conversation), retourne un historique vide.
+            return []
+            
+    except Exception as e:
+        logger.error(f"Erreur lors du chargement de l'historique avec HfFileSystem: {e}")
+        return []
+
+
+def save_conversation_turn(
+    user_id: str, 
+    conversation_id: str, 
+    prompt: str, 
+    ai_response: str
+) -> bool:
+    """
+    Lit l'historique existant, ajoute le nouveau tour de parole et écrit 
+    (crée/met à jour) le fichier JSON dans le dataset Hugging Face via HfApi.
+    """
+    file_path = _get_conversation_file_path(user_id, conversation_id)
+    
+    # 1. Tenter de charger l'historique existant
+    current_history = load_conversation_history(user_id, conversation_id)
+        
+    # 2. Ajouter le nouveau tour de parole
+    new_turn = {
+        "user_id": user_id,
+        "timestamp": datetime.now().isoformat(),
+        "messages": [
+            {"role": "user", "text": prompt},
+            {"role": "assistant", "text": ai_response}
+        ]
+    }
+    current_history.append(new_turn)
+
+    # 3. Préparer le contenu
+    content_to_upload = json.dumps(current_history, indent=4)
+    tmp_file_path = None
+    
+    # 4. Utiliser un fichier temporaire pour l'upload avec HfApi (méthode robuste)
+    try:
+        api = HfApi(token=HF_TOKEN)
+        
+        # Écrire le contenu dans un fichier temporaire
+        with tempfile.NamedTemporaryFile(mode='w+', delete=False, encoding='utf-8') as tmp_file:
+            tmp_file.write(content_to_upload)
+            tmp_file_path = tmp_file.name
+
+        # Utiliser l'API officielle pour uploader/mettre à jour le fichier
+        api.upload_file(
+            path_or_fileobj=tmp_file_path,
+            path_in_repo=file_path,
+            repo_id=GEMINI_HF_REPO_ID,
+            repo_type="dataset", # Spécifier que c'est un dataset
+            commit_message=f"Save/Update conversation {conversation_id} for user {user_id}"
+        )
+        
+        # S'assurer que le fichier temporaire est nettoyé
+        if tmp_file_path and os.path.exists(tmp_file_path):
+             os.remove(tmp_file_path)
+
+        logger.info(f"Conversation {conversation_id} sauvegardée avec succès via HfApi.")
+        return True
+        
+    except Exception as e:
+        # Nettoyage en cas d'erreur
+        if tmp_file_path and os.path.exists(tmp_file_path):
+             os.remove(tmp_file_path)
+             
+        logger.error(f"Échec de la sauvegarde HF via HfApi: {e}")
+        return False
+
+# --- Fonction principale de streaming (Adaptée à l'API Externe) ---
+
+def generate_streaming_response(
+    user_id: str, 
+    conversation_id: str, 
+    prompt: str
+) -> Generator[str, None, None]: 
+    """
+    Appelle le backend LLM externe et génère une réponse en streaming.
+    """
+    
+    # 1. Charger l'historique existant pour fournir le contexte à l'IA
+    # Cette fonction retourne [] si le fichier n'existe pas.
+    history = load_conversation_history(user_id, conversation_id)
+    
+    # 2. Préparer les données pour la requête
+    payload = {
+        "prompt": prompt,
+        "conversation_id": conversation_id,
+        # NOUVEAU: Ajouter l'historique de la conversation
+        "history": history 
+    }
+
+    headers = {
+        "Content-Type": "application/json",
+        "X-User-ID": user_id 
+    }
+
+    # 3. Appeler l'API externe en streaming
+    try:
+        # Utilisation de 'stream=True' pour traiter la réponse au fur et à mesure
+        with requests.post(EXTERNAL_LLM_API_URL, headers=headers, json=payload, stream=True) as response:
+            
+            # Vérifier si la requête a réussi
+            if response.status_code != 200:
+                logger.error(f"Erreur du backend externe: {response.status_code} - {response.text}")
+                error_json = json.dumps({'type': 'ERROR', 'text': f"Erreur backend externe: {response.status_code}"})
+                yield f"data: {error_json}\n\n"
+                return
+
+            # Traiter le flux de données
+            for line in response.iter_lines():
+                if line:
+                    # Le format attendu est 'data: {"content": "..."}' ou 'data: [DONE]'
+                    line_str = line.decode('utf-8')
+                    if line_str.startswith('data:'):
+                        data_content = line_str[5:].strip() # Récupère le JSON après 'data:'
+                        
+                        if data_content == '[DONE]':
+                            # Arrêter le flux après [DONE]
+                            break 
+                        
+                        # Tenter de parser le JSON pour extraire le texte
+                        try:
+                            chunk_data = json.loads(data_content)
+                            text_chunk = chunk_data.get('content', '')
+
+                            if text_chunk:
+                                # Format de chunk pour le front-end
+                                chunk_json = json.dumps({'type': 'CHUNK', 'text': text_chunk})
+                                yield f"data: {chunk_json}\n\n"
+
+                        except json.JSONDecodeError:
+                            logger.warning(f"Erreur de décodage JSON dans le flux: {data_content}")
+                            continue # Passer à la ligne suivante si ce n'est pas un JSON valide
+
+    except requests.exceptions.RequestException as e:
+        logger.error(f"Échec de la connexion au backend LLM: {e}")
+        error_json = json.dumps({'type': 'ERROR', 'text': f"Échec de la connexion au service LLM: {e}"})
+        yield f"data: {error_json}\n\n"
+        
+    # Événement de fin de flux (FINALE)
+    final_end_json = json.dumps({'type': 'END', 'conversation_id': conversation_id, 'title': ''})
+    yield f"data: {final_end_json}\n\n"
+    
+
+# NOUVEAU: Fonction pour charger uniquement le titre (basé sur le premier prompt)
+def _get_conversation_title(history: List[Dict]) -> str:
+    """
+    Extrait un titre de conversation à partir du premier prompt utilisateur.
+
+    Args:
+        history (List[Dict]): L'historique complet de la conversation chargé depuis le fichier JSON.
+
+    Returns:
+        str: Le titre de la conversation (le premier prompt tronqué) ou 'Nouvelle Conversation' si vide.
+    """
+    # Vérifie si l'historique est non-vide et si le premier tour contient des messages
+    if history and history[0].get('messages') and len(history[0]['messages']) > 0:
+        # Tente d'extraire le texte du premier message utilisateur
+        first_prompt = history[0]['messages'][0].get('text', 'Conversation sans titre')
+        
+        # Limiter et nettoyer pour un titre
+        # Tronque le titre à 50 caractères et ajoute '...'
+        return first_prompt[:50] + '...' if len(first_prompt) > 50 else first_prompt
+        
+    # Cas où le fichier existe mais est vide ou ne contient pas encore de message
+    return 'Nouvelle Conversation'
+
+
+# MODIFICATION: Fonction pour lister tous les fichiers de conversation d'un utilisateur
+def list_user_conversations(user_id: str) -> List[Dict]:
+    """
+    Liste toutes les conversations d'un utilisateur, en lisant le titre (premier prompt).
+    Cette version est robuste face aux fichiers JSON corrompus ou incomplets.
+    
+    Args:
+        user_id (str): L'identifiant de l'utilisateur.
+
+    Returns:
+        List[Dict]: Une liste d'objets, chacun contenant {'id': str, 'title': str}.
+    """
+    try:
+        # Initialisation du système de fichiers Hugging Face
+        fs = HfFileSystem(token=HF_TOKEN)
+        repo_path = f"datasets/{GEMINI_HF_REPO_ID}"
+        user_dir = f"{repo_path}/{user_id}/"
+        
+        conversations_list = []
+        
+        # 1. Vérifie si le répertoire de l'utilisateur existe
+        if fs.exists(user_dir):
+            files = fs.ls(user_dir, detail=False)
+            
+            for file in files:
+                if file.endswith('.json'):
+                    conversation_id = file.split('/')[-1].replace('.json', '')
+                    full_path = f"{repo_path}/{user_id}/{conversation_id}.json"
+                    
+                    # 2. Charger l'historique de ce fichier (avec gestion des erreurs)
+                    history = []
+                    try:
+                        with fs.open(full_path, 'r', encoding='utf-8') as f:
+                            history = json.load(f)
+                    except json.JSONDecodeError as e:
+                        # Gère spécifiquement les erreurs de format JSON (fichier corrompu ou vide)
+                        logger.warning(f"Fichier corrompu ou vide trouvé : {full_path}. Ignoré. Erreur: {e}")
+                        continue
+                    except Exception as e:
+                        # Gère toute autre erreur de lecture/réseau
+                        logger.error(f"Impossible de lire le fichier {full_path}: {e}")
+                        continue
+                        
+                    # 3. Extraire le titre à partir de l'historique chargé
+                    title = _get_conversation_title(history)
+                    
+                    # 4. Ajouter à la liste finale
+                    conversations_list.append({
+                        "id": conversation_id,
+                        "title": title
+                    })
+
+            # Retourne la liste des conversations valides
+            return conversations_list
+        else:
+            # Retourne une liste vide si le répertoire utilisateur n'existe pas
+            return []
+            
+    except Exception as e:
+        # Gère une erreur globale (e.g., problème de connexion à Hugging Face)
+        logger.error(f"Erreur lors du listage des conversations pour {user_id}: {e}")
+        return []
+
+# ----------------------------------------------------------------------
+# NOUVELLES FONCTIONS DE SUPPRESSION
+# ----------------------------------------------------------------------
+
+def delete_specific_conversation(user_id: str, conversation_id: str) -> bool:
+    """
+    Supprime un fichier de conversation spécifique dans le dataset Hugging Face.
+    """
+    file_path = _get_conversation_file_path(user_id, conversation_id)
+    
+    try:
+        fs = HfFileSystem(token=HF_TOKEN)
+        repo_path = f"datasets/{GEMINI_HF_REPO_ID}"
+        full_path = f"{repo_path}/{file_path}"
+
+        if fs.exists(full_path):
+            # Utiliser la méthode 'rm' de HfFileSystem pour supprimer le fichier
+            fs.rm(full_path)
+            logger.info(f"Conversation spécifique {conversation_id} de {user_id} supprimée avec succès.")
+            return True
+        else:
+            logger.warning(f"Tentative de suppression: Fichier {full_path} non trouvé.")
+            return False # Retourne False si non trouvé, mais la suppression est effective
+
+    except Exception as e:
+        logger.error(f"Erreur lors de la suppression de la conversation {conversation_id}: {e}")
+        return False
+
+
+def delete_all_user_conversations(user_id: str) -> bool:
+    """
+    Supprime le répertoire complet de l'utilisateur dans le dataset Hugging Face,
+    incluant toutes ses conversations.
+    """
+    try:
+        fs = HfFileSystem(token=HF_TOKEN)
+        repo_path = f"datasets/{GEMINI_HF_REPO_ID}"
+        user_dir = f"{repo_path}/{user_id}/"
+        
+        if fs.exists(user_dir):
+            # Utiliser la méthode 'rm' de HfFileSystem pour supprimer le répertoire et son contenu
+            fs.rm(user_dir, recursive=True)
+            logger.info(f"Toutes les conversations pour l'utilisateur {user_id} ont été supprimées.")
+            return True
+        else:
+            logger.warning(f"Tentative de suppression globale: Répertoire utilisateur {user_dir} non trouvé.")
+            return True # Considéré comme un succès si le répertoire n'existe pas
+
+    except Exception as e:
+        logger.error(f"Erreur lors de la suppression de toutes les conversations pour {user_id}: {e}")
+        return False
+
+# ----------------------------------------------------------------------
+# NOUVELLE FONCTION: Traitement des fichiers
+# ----------------------------------------------------------------------
+
+def process_uploaded_files(uploaded_files: List[FileStorage]) -> List[Dict]:
+    """
+    Traite la liste des objets FileStorage (fichiers uploadés via Flask)
+    pour les encoder en Base64 et les préparer pour l'API externe.
+    
+    Args:
+        uploaded_files (List[FileStorage]): Liste des fichiers provenant de request.files.
+        
+    Returns:
+        List[Dict]: Liste de dictionnaires au format:
+                    {'filename': str, 'content': str (base64), 'mime_type': str}
+    """
+    processed_files = []
+    
+    for file in uploaded_files:
+        try:
+            # Lire le contenu du fichier
+            file_bytes = file.read()
+            # Encoder en Base64
+            encoded_content = base64.b64encode(file_bytes).decode('utf-8')
+            
+            processed_files.append({
+                "filename": file.filename,
+                "content": encoded_content,
+                "mime_type": file.mimetype
+            })
+            logger.info(f"Fichier '{file.filename}' traité et encodé en base64.")
+            
+        except Exception as e:
+            logger.error(f"Erreur lors du traitement du fichier {file.filename}: {e}")
+            # Le fichier est ignoré, mais la conversation peut continuer
+            continue
+            
+    return processed_files
+
+
+# ----------------------------------------------------------------------
+# NOUVELLE FONCTION principale de streaming AVEC fichiers
+# ----------------------------------------------------------------------
+
+def generate_streaming_response_with_files(
+    user_id: str, 
+    conversation_id: str, 
+    prompt: str,
+    files_data: List[Dict] # NOUVEAU: Liste des fichiers déjà encodés en base64
+) -> Generator[str, None, None]: 
+    """
+    Appelle le backend LLM externe (route avec fichiers) et génère une réponse en streaming.
+    """
+    
+    # 1. Charger l'historique existant
+    history = load_conversation_history(user_id, conversation_id)
+    
+    # 2. Préparer les données pour la requête (y compris les fichiers)
+    payload = {
+        "prompt": prompt,
+        "history": history,
+        "files": files_data # NOUVEAU: Ajout de la liste des fichiers
+    }
+
+    headers = {
+        "Content-Type": "application/json",
+        "X-User-ID": user_id 
+    }
+
+    # 3. Appeler l'API externe en streaming sur la NOUVELLE ROUTE
+    try:
+        # Utiliser la NOUVELLE URL pour la route multimodale
+        with requests.post(EXTERNAL_LLM_FILES_API_URL, headers=headers, json=payload, stream=True) as response:
+            
+            # Vérifier si la requête a réussi (gestion des erreurs du backend HF)
+            if response.status_code != 200:
+                logger.error(f"Erreur du backend externe (files): {response.status_code} - {response.text}")
+                error_json = json.dumps({'type': 'ERROR', 'text': f"Erreur backend externe (files): {response.status_code}"})
+                yield f"data: {error_json}\n\n"
+                return
+
+            # Traiter le flux de données (reste le même que l'ancienne fonction)
+            for line in response.iter_lines():
+                if line:
+                    line_str = line.decode('utf-8')
+                    if line_str.startswith('data:'):
+                        data_content = line_str[5:].strip()
+                        
+                        if data_content == '[DONE]':
+                            break 
+                        
+                        try:
+                            chunk_data = json.loads(data_content)
+                            text_chunk = chunk_data.get('content', '')
+
+                            if text_chunk:
+                                chunk_json = json.dumps({'type': 'CHUNK', 'text': text_chunk})
+                                yield f"data: {chunk_json}\n\n"
+
+                        except json.JSONDecodeError:
+                            logger.warning(f"Erreur de décodage JSON dans le flux: {data_content}")
+                            continue
+
+    except requests.exceptions.RequestException as e:
+        logger.error(f"Échec de la connexion au backend LLM (files): {e}")
+        error_json = json.dumps({'type': 'ERROR', 'text': f"Échec de la connexion au service LLM (files): {e}"})
+        yield f"data: {error_json}\n\n"
+        
+    # Événement de fin de flux (FINALE)
+    final_end_json = json.dumps({'type': 'END', 'conversation_id': conversation_id, 'title': ''})
+    yield f"data: {final_end_json}\n\n"

a6ea61c8-951a-413a-ba9d-7365d83fbd4d/mayproject/gemini_routes.py

@@ -0,0 +1,265 @@
+# gemini_routes.py - Version avec nouvelles routes de gestion de l'historique
+
+import logging
+import json
+import uuid 
+from flask import Blueprint, request, jsonify, Response, stream_with_context
+from decorators import api_session_required 
+from gemini_functions import (
+    get_user_id_from_session, 
+    generate_streaming_response,
+    list_user_conversations, # NOUVEL IMPORT
+    load_conversation_history, 
+    save_conversation_turn,
+    delete_specific_conversation,
+    delete_all_user_conversations,
+    process_uploaded_files, # NOUVEL IMPORT
+    generate_streaming_response_with_files, # NOUVEL IMPORT
+)
+
+gemini_bp = Blueprint('gemini_bp', __name__, url_prefix='/api/gemini')
+logger = logging.getLogger(__name__)
+
+    
+# ------------------------------------------------------------
+# Route: Charger l'historique d'une conversation
+# GET /api/gemini/chat/history/<conversation_id>
+# ------------------------------------------------------------
+@gemini_bp.route('/chat/history/<conversation_id>', methods=['GET'])
+@api_session_required
+def get_chat_history(client_user, conversation_id: str):
+    """
+    Récupère l'historique de la conversation pour un ID donné depuis le dataset HF.
+    """
+    user_id = client_user.get('user_id', get_user_id_from_session())
+    
+    if not conversation_id:
+        return jsonify({"success": False, "message": "L'ID de conversation est requis."}), 400
+    
+    try:
+        history = load_conversation_history(user_id, conversation_id)
+        # Retourne l'historique (ou [] si nouveau/non trouvé)
+        return jsonify({"success": True, "history": history})
+        
+    except Exception as e:
+        logger.error(f"Erreur lors du chargement de l'historique {conversation_id}: {e}")
+        # En cas d'erreur fatale, retourner une liste vide pour permettre la continuité
+        return jsonify({"success": True, "history": [], "message": "Erreur lors du chargement de l'historique."})
+
+
+# ------------------------------------------------------------
+# Route: Sauvegarder un tour de conversation 
+# POST /api/gemini/chat/save
+# ------------------------------------------------------------
+@gemini_bp.route('/chat/save', methods=['POST'])
+@api_session_required
+def save_chat_turn(client_user):
+    """
+    Sauvegarde un tour de conversation complet (prompt utilisateur + réponse AI) dans le dataset HF.
+    Cette route est destinée à être appelée par le front-end après le stream.
+    """
+    user_id = client_user.get('user_id', get_user_id_from_session())
+    
+    try:
+        data = request.get_json()
+    except Exception:
+        return jsonify({"success": False, "message": "Données JSON manquantes ou invalides."}), 400
+
+    conversation_id = data.get('conversation_id')
+    prompt = data.get('prompt', '').strip()
+    ai_response = data.get('ai_response', '').strip()
+    
+    if not conversation_id or not prompt or not ai_response:
+        return jsonify({"success": False, "message": "conversation_id, prompt, et ai_response sont requis."}), 400
+        
+    # Appel de la nouvelle fonction de sauvegarde
+    success = save_conversation_turn(user_id, conversation_id, prompt, ai_response)
+    
+    if success:
+        return jsonify({"success": True, "message": "Conversation sauvegardée avec succès."}), 200
+    else:
+        return jsonify({"success": False, "message": "Échec de la sauvegarde de la conversation."}), 500
+
+# ------------------------------------------------------------
+# Route unique: Envoyer un message et recevoir la réponse en STREAMING
+# POST /api/gemini/chat/message
+# ------------------------------------------------------------
+@gemini_bp.route('/chat/message', methods=['POST'])
+@api_session_required
+def send_message_stream(client_user):
+    # 1. Identification de l'utilisateur
+    user_id = client_user.get('user_id', get_user_id_from_session())
+    
+    # 2. Récupération des données (doit être un JSON dans le corps)
+    try:
+        data = request.get_json()
+    except Exception:
+        data = {} # Gérer le cas où le corps n'est pas un JSON valide
+
+    conversation_id = data.get('conversation_id')
+    prompt = data.get('prompt', '').strip()
+    
+    # Vérification du prompt
+    if not prompt:
+        return jsonify({"success": False, "message": "Le 'prompt' est requis."}), 400
+
+    # 3. Gestion de l'ID de conversation
+    if not conversation_id:
+        # Créer un nouvel ID si l'utilisateur envoie un nouveau message sans contexte
+        conversation_id = str(uuid.uuid4())
+        logger.info(f"Création d'un nouvel ID de conversation: {conversation_id} pour {user_id}")
+
+    # 4. Fonction générateur pour le streaming (Server-Sent Events - SSE)
+    def stream_generator():
+        # Envoie l'ID de conversation initial pour le front-end
+        yield f"data:{json.dumps({'type': 'CONV_ID', 'id': conversation_id})}\n\n"
+        
+        # Le flux de réponse de l'IA (qui appelle le backend externe)
+        try:
+            # generate_streaming_response retourne des strings au format SSE (data: JSON\n\n)
+            for json_chunk_string in generate_streaming_response(user_id, conversation_id, prompt):
+                yield json_chunk_string 
+                
+        except Exception as e:
+            logger.error(f"Erreur fatale dans le stream_generator: {e}")
+            error_json = json.dumps({'type': 'ERROR', 'text': 'Erreur interne du serveur lors du streaming.'})
+            yield f"data:{error_json}\n\n"
+            
+    # 5. Retourner la réponse en streaming (text/event-stream)
+    return Response(
+        stream_with_context(stream_generator()),
+        mimetype='text/event-stream',
+        headers={'Cache-Control': 'no-cache', 'Connection': 'keep-alive'}
+    )
+
+
+# Correction dans gemini_routes.py
+@gemini_bp.route('/chat/list', methods=['GET'])
+@api_session_required
+def get_chat_list(client_user):
+    user_id = client_user.get('user_id', get_user_id_from_session())
+    try:
+        # Utilise la nouvelle fonction qui retourne les objets complets
+        conversations = list_user_conversations(user_id)
+        
+        # IMPORTANT: Le frontend attend 'chats', non pas 'conversations'
+        return jsonify({"success": True, "chats": conversations})
+        
+    except Exception as e:
+        logger.error(f"Erreur lors du listage des conversations: {e}")
+        return jsonify({"success": False, "chats": [], "message": "Erreur lors du listage des conversations."}), 500
+
+# ------------------------------------------------------------
+# Route: Supprimer une conversation spécifique
+# DELETE /api/gemini/chat/delete/<conversation_id>
+# ------------------------------------------------------------
+@gemini_bp.route('/chat/delete/<conversation_id>', methods=['DELETE'])
+@api_session_required
+def delete_chat_specific(client_user, conversation_id: str):
+    """
+    Supprime le fichier d'une conversation spécifique.
+    """
+    user_id = client_user.get('user_id', get_user_id_from_session())
+    
+    if not conversation_id:
+        return jsonify({"success": False, "message": "L'ID de conversation est requis pour la suppression."}), 400
+
+    success = delete_specific_conversation(user_id, conversation_id)
+    
+    if success:
+        return jsonify({"success": True, "message": f"Conversation {conversation_id} supprimée avec succès."}), 200
+    else:
+        # Retourne 404 si le fichier n'a pas été trouvé ou 500 pour une erreur backend
+        return jsonify({"success": False, "message": f"Échec de la suppression de la conversation {conversation_id}."}), 500
+
+
+# ------------------------------------------------------------
+# Route: Supprimer TOUTES les conversations de l'utilisateur
+# DELETE /api/gemini/chat/delete_all
+# ------------------------------------------------------------
+@gemini_bp.route('/chat/delete_all', methods=['DELETE'])
+@api_session_required
+def delete_chat_all(client_user):
+    """
+    Supprime le répertoire complet de l'utilisateur, incluant toutes ses conversations.
+    """
+    user_id = client_user.get('user_id', get_user_id_from_session())
+    
+    # Sécurité: Ne pas permettre la suppression de l'utilisateur de secours TEST_USER_ID_FALLBACK
+    if user_id == 'TEST_USER_ID_FALLBACK':
+        return jsonify({"success": False, "message": "La suppression globale n'est pas autorisée pour l'utilisateur de secours."}), 403
+
+    success = delete_all_user_conversations(user_id)
+    
+    if success:
+        return jsonify({"success": True, "message": f"Toutes les conversations pour l'utilisateur {user_id} ont été supprimées."}), 200
+    else:
+        return jsonify({"success": False, "message": "Échec de la suppression de toutes les conversations."}), 500
+
+# ------------------------------------------------------------
+# NOUVELLE ROUTE: Envoyer un message AVEC fichiers en STREAMING
+# POST /api/gemini/chat/message_with_files
+# ------------------------------------------------------------
+@gemini_bp.route('/chat/message_with_files', methods=['POST'])
+@api_session_required
+def send_message_with_files_stream(client_user):
+    """
+    Gère l'envoi d'un prompt et de plusieurs fichiers, les encode en Base64,
+    et streame la réponse de l'IA via la route multimodale du backend externe.
+    """
+    # 1. Identification de l'utilisateur
+    user_id = client_user.get('user_id', get_user_id_from_session())
+    
+    # 2. Récupération des données du formulaire (le formulaire est de type multipart/form-data)
+    # Les champs texte (prompt, conversation_id) sont dans request.form
+    conversation_id = request.form.get('conversation_id')
+    prompt = request.form.get('prompt', '').strip()
+    
+    # 3. Récupération des fichiers uploadés
+    # Flask stocke les fichiers dans request.files
+    # On utilise list(request.files.values()) pour obtenir tous les objets FileStorage
+    uploaded_files = list(request.files.values()) 
+    
+    # 4. Vérification minimale
+    if not prompt and not uploaded_files:
+        return jsonify({"success": False, "message": "Le 'prompt' ou au moins un fichier est requis."}), 400
+
+    # 5. Traitement des fichiers (Base64 encoding)
+    files_data_b64 = process_uploaded_files(uploaded_files)
+    
+    # Double vérification si tous les fichiers ont échoué
+    if not prompt and not files_data_b64:
+        return jsonify({"success": False, "message": "Le 'prompt' est vide et aucun fichier valide n'a pu être traité."}), 400
+    
+    # 6. Gestion de l'ID de conversation
+    if not conversation_id:
+        conversation_id = str(uuid.uuid4())
+        logger.info(f"Création d'un nouvel ID de conversation (avec fichiers): {conversation_id} pour {user_id}")
+
+    # 7. Fonction générateur pour le streaming (Server-Sent Events - SSE)
+    def stream_generator():
+        # Envoie l'ID de conversation initial pour le front-end
+        yield f"data:{json.dumps({'type': 'CONV_ID', 'id': conversation_id})}\n\n"
+        
+        # Le flux de réponse de l'IA (qui appelle le backend externe avec fichiers)
+        try:
+            # Appel de la NOUVELLE fonction
+            for json_chunk_string in generate_streaming_response_with_files(
+                user_id, 
+                conversation_id, 
+                prompt,
+                files_data_b64 # Passage des fichiers encodés
+            ):
+                yield json_chunk_string 
+                
+        except Exception as e:
+            logger.error(f"Erreur fatale dans le stream_generator (avec fichiers): {e}")
+            error_json = json.dumps({'type': 'ERROR', 'text': 'Erreur interne du serveur lors du streaming.'})
+            yield f"data:{error_json}\n\n"
+            
+    # 8. Retourner la réponse en streaming (text/event-stream)
+    return Response(
+        stream_with_context(stream_generator()),
+        mimetype='text/event-stream',
+        headers={'Cache-Control': 'no-cache', 'Connection': 'keep-alive'}
+    )

a6ea61c8-951a-413a-ba9d-7365d83fbd4d/mayproject/hf_deploy_manager.py

@@ -0,0 +1,318 @@
+# hf_deploy_manager.py
+# Implémentation du Plan de Travail pour l'Orchestration, la Surveillance et la Maintenance des Spaces Hugging Face.
+
+import os
+import re
+import logging
+from typing import Optional, Dict
+from huggingface_hub import HfApi
+from huggingface_hub.utils import HfHubHTTPError # <-- NOUVEL EMPLACEMENT DE L'IMPORT
+import requests
+
+# --- Configuration et Initialisation ---
+logger = logging.getLogger(__name__)
+
+# Ces variables d'environnement sont nécessaires pour le bon fonctionnement.
+HF_TOKEN = os.environ.get("HF_TOKEN")
+HF_DATASET_REPO_ID = os.environ.get("HF_DATASET_REPO_ID") # Le Dataset qui contient le code utilisateur
+
+# Initialisation de l'API Hugging Face
+# Le jeton est lu automatiquement de l'environnement si l'initialisation est faite avec token=HF_TOKEN
+api = HfApi(token=HF_TOKEN) 
+
+# --- PHASE 1 : Orchestration du Déploiement (La Création du Space) ---
+
+def _get_space_id(user_id: str, repo_slug: str) -> str:
+    """
+    1. Création d'ID unique : Crée un format de nommage unique et sûr pour le Space HF.
+    Format: [user_id_slug]-[repo_slug_slug] (Sans organisation).
+    """
+    # Simple slugification pour s'assurer qu'il n'y a pas de caractères non autorisés dans l'ID
+    safe_user_id = re.sub(r'[^a-zA-Z0-9-]', '-', user_id).lower()
+    safe_repo_slug = re.sub(r'[^a-zA-Z0-9-]', '-', repo_slug).lower()
+    
+    # Construction de l'ID du Space sans l'organisation
+    space_id = f"{safe_user_id}-{safe_repo_slug}"
+    return space_id
+
+def get_public_space_url(space_id: str) -> str:
+    """
+    Génère l'URL publique complète pour un Space Hugging Face à partir de son ID.
+    L'URL est toujours construite à partir de l'ID du Space.
+    """
+    safe_space_id = space_id.replace('/', '-')
+    # Format standard de Hugging Face Spaces
+    space_url = f"https://{safe_space_id}.hf.space"
+    return space_url
+
+def _generate_space_readme(user_id: str, repo_slug: str, sdk_type: str = "gradio") -> str:
+    """
+    2. Configuration du Code Source : Génère le contenu du fichier README.md.
+    Prend en charge les SDKs standards (gradio, streamlit) et 'docker' pour les frameworks.
+    """
+    if not HF_DATASET_REPO_ID:
+        raise ValueError("HF_DATASET_REPO_ID n'est pas configuré dans l'environnement.")
+
+    # Chemin où se trouve le code source de l'utilisateur dans le Dataset
+    user_data_path = f"{user_id}/{repo_slug}"
+
+    readme_content = f"""
+---
+title: {repo_slug} - Deployment
+emoji: 🚀
+colorFrom: blue
+colorTo: green
+sdk: {sdk_type}
+external_data:
+  - {HF_DATASET_REPO_ID}:{user_data_path}
+---
+
+# Space de Déploiement pour {repo_slug}
+Ce Space est un déploiement automatisé du projet de l'utilisateur `{user_id}`.
+
+Le code source est monté depuis le Dataset Hugging Face : `{HF_DATASET_REPO_ID}`
+Chemin spécifique de la source : `{user_data_path}`
+
+Le type de SDK utilisé est `{sdk_type}`.
+"""
+    return readme_content.strip()
+
+def _generate_default_requirements() -> str:
+    """
+    Génère un fichier requirements.txt minimal pour le Dockerfile par défaut.
+    Gunicorn est inclus car il est utilisé dans le Dockerfile.
+    """
+    return """
+# Dépendances requises pour l'application.
+# L'utilisateur doit modifier ce fichier avec les dépendances spécifiques à son projet (Flask, FastAPI, Django, etc.)
+gunicorn
+"""
+
+def _generate_default_dockerfile(base_image: str = "python:3.10-slim") -> str:
+    """
+    3. Fichier d'Environnement : Créer un Dockerfile de base simple pour les déploiements de type 'docker'
+    pour les frameworks web (Flask, FastAPI, Django).
+    """
+    dockerfile_content = f"""
+# Dockerfile généré par défaut par hf_deploy_manager.py
+
+FROM {base_image}
+
+# Définir le répertoire de travail
+WORKDIR /app
+
+# Les fichiers sont montés via external_data dans le dossier de travail.
+# L'utilisateur DOIT fournir un fichier 'requirements.txt' pour les dépendances.
+# Nous copions le fichier requirements.txt généré ou fourni
+COPY requirements.txt requirements.txt
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Installer Gunicorn, un serveur WSGI souvent utilisé pour les applications web
+# Gunicorn est déjà listé dans requirements.txt généré.
+
+# Exécuter l'application avec Gunicorn.
+# L'application doit écouter sur le port 7860 et l'objet de l'application doit être nommé 'app'
+# dans le fichier de point d'entrée 'app.py' (commun pour Flask/FastAPI/Streamlit/Gradio).
+# Pour Django, l'utilisateur devra créer son propre Dockerfile.
+# Note: HF Spaces expose les applications web sur le port 7860.
+CMD exec gunicorn --bind 0.0.0.0:7860 app:app
+"""
+    return dockerfile_content.strip()
+
+def deploy_repo_to_space(user_id: str, repo_slug: str, sdk_type: str = "gradio") -> Dict[str, str]:
+    """
+    4. Déploiement Complet : Crée et configure un nouveau Space Hugging Face.
+    
+    Returns:
+        Un dictionnaire contenant le statut de succès, l'ID COMPLET (owner/repo_name) et l'URL publique.
+    """
+    # Étape 1: Obtenir le slug du dépôt (e.g., a6ea61c8-...)
+    space_id_slug = _get_space_id(user_id, repo_slug)
+    
+    # Étape 2: Construire l'ID complet Hugging Face (e.g., ernestmindres/a6ea61c8-...)
+    full_space_id = f"{user_id}/{space_id_slug}"
+    
+    # Valider le type de SDK
+    valid_sdks = ["gradio", "streamlit", "docker", "static"]
+    if sdk_type.lower() not in valid_sdks:
+        return {"success": False, "message": f"SDK non valide: {sdk_type}. Types acceptés: {', '.join(valid_sdks)}."}
+
+    try:
+        logger.info(f"Tentative de création du Space: {full_space_id}...")
+
+        # 1. Créer le dépôt de type 'space' - Utilise l'ID COMPLET
+        api.create_repo(
+            repo_id=full_space_id, 
+            repo_type="space",
+            private=False,
+            space_sdk=sdk_type
+        )
+
+        # 2. Générer le contenu du README.md
+        # Assurez-vous que _generate_space_readme est définie
+        readme_content = _generate_space_readme(user_id, repo_slug, sdk_type)
+        
+        # 3. Uploader le README.md - Utilise l'ID COMPLET
+        api.upload_file(
+            path_or_fileobj=readme_content.encode('utf-8'),
+            path_in_repo="README.md",
+            repo_id=full_space_id,
+            repo_type="space",
+            commit_message="Initial README.md with external_data directive."
+        )
+
+        # 4. Uploader les fichiers requis pour le mode 'docker'
+        if sdk_type.lower() == "docker":
+            # 4a. Dockerfile (Assurez-vous que _generate_default_dockerfile est définie)
+            dockerfile_content = _generate_default_dockerfile()
+            api.upload_file(
+                path_or_fileobj=dockerfile_content.encode('utf-8'),
+                path_in_repo="Dockerfile",
+                repo_id=full_space_id, # Utilise l'ID COMPLET
+                repo_type="space",
+                commit_message="Initial Dockerfile for web frameworks."
+            )
+            
+            # 4b. requirements.txt (Assurez-vous que _generate_default_requirements est définie)
+            requirements_content = _generate_default_requirements()
+            api.upload_file(
+                path_or_fileobj=requirements_content.encode('utf-8'),
+                path_in_repo="requirements.txt",
+                repo_id=full_space_id, # Utilise l'ID COMPLET
+                repo_type="space",
+                commit_message="Initial requirements.txt."
+            )
+
+        # 5. Retourner l'URL publique
+        # On utilise le SLUG (space_id_slug) pour obtenir l'URL publique
+        space_url = get_public_space_url(space_id_slug) 
+        logger.info(f"Space '{full_space_id}' créé avec succès. URL: {space_url}")
+        
+        return {
+            "success": True, 
+            "message": f"Space créé et configuré avec succès pour SDK: {sdk_type}.",
+            "space_id": full_space_id, # IMPORTANT: Retourne l'ID COMPLET
+            "space_url": space_url
+        }
+
+    except HfHubHTTPError as e:
+        # On logue l'erreur avec l'ID complet pour le débogage
+        logger.error(f"Erreur HF lors du déploiement de {full_space_id}: {e}")
+        status_code = e.response.status_code
+        
+        # Gérer le cas où le Space existe déjà (code 409 Conflict)
+        if status_code == 409:
+            # Récupère l'URL pour la renvoyer au client
+            space_url = get_public_space_url(space_id_slug)
+            return {
+                "success": True, 
+                "message": f"Le Space '{full_space_id}' existe déjà. Vous pouvez procéder à la surveillance du statut via cet ID.",
+                "space_id": full_space_id, # IMPORTANT: Retourne l'ID COMPLET
+                "space_url": space_url
+            }
+        
+        # Gérer les autres erreurs HTTP
+        return {
+            "success": False, 
+            "message": f"Erreur lors de la création du Space: {status_code} - **{e}**."
+        }
+        
+    except ValueError as e:
+        return {"success": False, "message": str(e)}
+    except Exception as e:
+        logger.error(f"Erreur inattendue lors du déploiement: {e}")
+        return {"success": False, "message": f"Erreur inattendue: {str(e)}"}
+
+def _get_hf_repo_id(user_id: str, space_id_slug: str) -> str:
+    """
+    Crée l'ID complet du dépôt Hugging Face (ex: user_id/space_id_slug).
+    """
+    # Note: Si le space est créé sans organisation, HF le met sous l'utilisateur.
+    # Pour une organisation, vous devez adapter (ex: org_id/space_id_slug)
+    return f"{user_id}/{space_id_slug}"
+
+
+def get_space_status(space_id: str) -> Dict[str, str]:
+    """
+    5. Vérification du Statut : Utilise HfApi().repo_info pour obtenir l'état (Ex: Running, Building, Error).
+    
+    ATTENTION: 'space_id' DOIT être l'ID complet du dépôt Hugging Face (ex: 'utilisateur/nom-du-space').
+    """
+    try:
+        # Utiliser repo_info (méthode standard pour obtenir des informations complètes sur le dépôt)
+        info = api.repo_info(repo_id=space_id, repo_type="space")
+        
+        # Le statut du Space est généralement disponible à deux endroits, on vérifie les deux.
+        # Le 'stage' est le statut de compilation/exécution (Building, Running, Error).
+        status = 'Unknown'
+        if info.cardData and 'space_runtime_stage' in info.cardData:
+            status = info.cardData['space_runtime_stage']
+        elif info.spaces_status and info.spaces_status.stage:
+             status = info.spaces_status.stage
+
+        # Si le status est encore 'Unknown', on peut essayer de deviner (ex: si 'stage' est manquant)
+        if status == 'Unknown':
+            if info.spaces_status and info.spaces_status.stage:
+                status = info.spaces_status.stage
+            
+            # Fallback si l'API ne renvoie pas la structure attendue
+            if status == 'Unknown':
+                 status = 'No stage'
+
+        return {
+            "success": True, 
+            "status": status,
+            "message": f"Le Space '{space_id}' est dans l'état: {status}"
+        }
+    except HfHubHTTPError as e:
+        logger.error(f"Erreur lors de la récupération du statut de {space_id}: Client error '{e.response.status_code}' for url '{e.response.url}' (Détails: {e})")
+        
+        # Le statut 404 est retourné si le Space n'existe pas (souvent à cause d'un ID incomplet)
+        if e.response.status_code == 404:
+            return {"success": False, "status": "Error", "message": f"Space non trouvé ou erreur d'API. Vérifiez que l'ID complet '{space_id}' est correct. (Code: 404)"}
+        
+        # Autres erreurs HF
+        return {"success": False, "status": "Error", "message": f"Erreur d'API Hugging Face: {e.response.status_code}"}
+        
+    except Exception as e:
+        logger.error(f"Erreur inattendue lors de la récupération du statut de {space_id}: {e}")
+        return {"success": False, "status": "Error", "message": f"Erreur inattendue lors de la vérification du statut: {str(e)}"}
+
+
+def fetch_space_logs(space_id: str, logs_type: str = "build") -> Dict[str, str]:
+    """
+    6. Récupération des Logs : Utilise HfApi().get_logs pour obtenir les logs.
+    """
+    try:
+        logs = api.get_logs(repo_id=space_id, repo_type="space", logs_type=logs_type)
+        
+        return {
+            "success": True, 
+            "logs": logs,
+            "message": f"Logs de type '{logs_type}' récupérés avec succès pour le Space '{space_id}'."
+        }
+    except HfHubHTTPError as e:
+        logger.error(f"Erreur lors de la récupération des logs de {space_id}: {e}")
+        return {"success": False, "logs": "", "message": f"Space non trouvé ou erreur d'API: {e.response.status_code}"}
+    except Exception as e:
+        logger.error(f"Erreur inattendue lors de la récupération des logs: {e}")
+        return {"success": False, "logs": "", "message": f"Erreur inattendue: {str(e)}"}
+
+
+def stop_space(space_id: str) -> Dict[str, str]:
+    """
+    7. Arrêt du Space (Optionnel) : Utilise HfApi().pause_space pour mettre le Space en pause.
+    """
+    try:
+        api.pause_space(repo_id=space_id)
+        
+        return {
+            "success": True, 
+            "message": f"Le Space '{space_id}' a été mis en pause (Stopped) avec succès."
+        }
+    except HfHubHTTPError as e:
+        logger.error(f"Erreur lors de l'arrêt du Space {space_id}: {e}")
+        return {"success": False, "message": f"Space non trouvé ou erreur d'API: {e.response.status_code}. Space déjà arrêté?"}
+    except Exception as e:
+        logger.error(f"Erreur inattendue lors de l'arrêt du Space: {e}")
+        return {"success": False, "message": f"Erreur inattendue: {str(e)}"}

a6ea61c8-951a-413a-ba9d-7365d83fbd4d/mayproject/huggingface_repo_manager.py

@@ -0,0 +1,1174 @@
+# huggingface_repo_manager.py
+
+from werkzeug.datastructures import FileStorage # NÉCESSAIRE pour typer le paramètre 'files'
+import os
+import shutil
+import logging
+import json # <--- NOUVEL
+from huggingface_hub import HfApi, HfFileSystem, CommitOperationAdd # <-- MODIFICATION
+from huggingface_hub.utils import HfHubHTTPError
+from typing import Optional, Dict, List, Tuple
+from io import BytesIO
+import uuid # <-- NOUVEL IMPORT
+from datetime import datetime, timedelta # <-- MODIFIER CETTE LIGNE
+from config import HF_DATASET_REPO_ID, IMAGE_STORAGE_HF_REPO_ID, PULL_REQUESTS_HF_REPO_ID, HF_TOKEN
+
+logger = logging.getLogger(__name__)
+
+# --- Configuration Hugging Face ---
+HF_DATASET_REPO_ID = os.environ.get("HF_DATASET_REPO_ID")
+IMAGE_STORAGE_HF_REPO_ID = os.environ.get("IMAGE_STORAGE_HF_REPO_ID") # <-- AJOUTER CETTE LIGNE
+api = HfApi()
+fs = HfFileSystem()
+
+# --- Constantes pour le stockage utilisateur ---
+METADATA_FILE_NAME = "metadata.json"
+
+TEMP_UPLOAD_DIR = "/tmp/hf_uploads" # <-- AJOUTER/DÉPLACER ICI
+
+def _get_user_base_path(user_id: str) -> str:
+    """Retourne le chemin du dossier principal de l'utilisateur dans le Dataset HF."""
+    # Le chemin principal est l'UUID de l'utilisateur
+    return user_id
+
+def _get_user_metadata_path(user_id: str) -> str:
+    """Retourne le chemin complet du fichier de métadonnées utilisateur."""
+    # Structure: user_id/metadata.json
+    return f"{_get_user_base_path(user_id)}/{METADATA_FILE_NAME}"
+# --- NOUVELLES Fonctions Utilitaires pour les chemins de Variables/Secrets ---
+
+
+SECRETS_FILE_PREFIX = "secrets__"
+VARIABLES_FILE_PREFIX = "variables__"
+
+def _get_repo_secrets_path(user_id: str, repo_slug: str) -> str:
+    """Retourne le chemin complet du fichier JSON des secrets pour un dépôt."""
+    # Structure: user_id/secrets__repo_slug.json
+    return f"{_get_user_base_path(user_id)}/{SECRETS_FILE_PREFIX}{repo_slug}.json"
+
+def _get_repo_variables_path(user_id: str, repo_slug: str) -> str:
+    """Retourne le chemin complet du fichier JSON des variables pour un dépôt."""
+    # Structure: user_id/variables__repo_slug.json
+    return f"{_get_user_base_path(user_id)}/{VARIABLES_FILE_PREFIX}{repo_slug}.json"
+
+
+# --- NOUVELLE Fonction Utilitaires pour le formatage du temps écoulé ---
+
+def _format_time_ago(datetime_str: str) -> str:
+    """
+    Formate une chaîne de date/heure ISO (UTC) en une chaîne de temps écoulé 
+    (par ex. 'il y a 2 jours', 'le mois dernier').
+    """
+    try:
+        # Hugging Face renvoie une chaîne ISO formatée (ex: 2025-12-13T17:47:07.000Z)
+        # On remplace 'Z' pour être compatible avec `fromisoformat` si Python < 3.11 ou si le format varie.
+        last_modified_dt = datetime.fromisoformat(datetime_str.replace('Z', '+00:00'))
+    except ValueError:
+        return "Date invalide"
+
+    # Utiliser le fuseau horaire de la date/heure lue (ici UTC)
+    now = datetime.now(last_modified_dt.tzinfo) 
+    diff: timedelta = now - last_modified_dt
+
+    # Différence en secondes
+    seconds = int(diff.total_seconds())
+    
+    # Gérer le cas où la date est dans le futur (très rare)
+    if seconds < 0:
+        return "à l'instant"
+
+    # Tableau des intervalles de temps
+    intervals = (
+        ('années', 31536000),  # 365 jours
+        ('mois', 2592000),     # 30 jours (approximation)
+        ('semaines', 604800),  # 7 jours
+        ('jours', 86400),
+        ('heures', 3600),
+        ('minutes', 60),
+        ('secondes', 1),
+    )
+
+    for name, count in intervals:
+        value = seconds // count
+        if value >= 1:
+            # Gérer les pluriels et le formatage "il y a"
+            s = 's' if value > 1 and name not in ['mois', 'années'] else ''
+            
+            if name == 'années':
+                return f"il y a {value} an{s}"
+            if name == 'mois':
+                return f"il y a {value} mois"
+            if name == 'semaines':
+                return f"il y a {value} semaine{s}"
+            if name == 'jours':
+                return f"il y a {value} jour{s}"
+            if name == 'heures':
+                return f"il y a {value} heure{s}"
+            if name == 'minutes':
+                return f"il y a {value} minute{s}"
+            if name == 'secondes':
+                return f"il y a {value} seconde{s}"
+
+    return "à l'instant"
+
+
+def upload_files_to_repo_backend(
+    user_id: str,
+    repo_slug: str,
+    files: List[FileStorage], 
+    commit_message: str,
+    commit_description: Optional[str] = None,
+    branch: str = "main",
+    repo_id: Optional[str] = None
+) -> tuple[bool, str]:
+    """
+    Téléverse une liste de fichiers (incluant ceux dans des sous-dossiers) 
+    vers le sous-dossier de dépôt de l'utilisateur sur Hugging Face
+    en une seule commit atomique (Git-like) en utilisant un dossier temporaire.
+    """
+    repo_id = repo_id if repo_id else HF_DATASET_REPO_ID
+    if not repo_id:
+        return False, "Erreur de configuration: Repository Hugging Face non défini."
+    if not files:
+        return False, "Aucun fichier à téléverser."
+
+    # 1. Préparer le dossier temporaire local
+    local_temp_repo_path = os.path.join(TEMP_UPLOAD_DIR, user_id, repo_slug)
+    
+    # S'assurer que le dossier local temporaire est propre et existe
+    if os.path.exists(local_temp_repo_path):
+        shutil.rmtree(local_temp_repo_path)
+    os.makedirs(local_temp_repo_path, exist_ok=True)
+
+    local_file_paths = []
+
+    try:
+        # 2. Sauvegarder tous les fichiers uploadés dans le dossier temporaire
+        for file_storage in files:
+            # --- CORRECTION POUR LA GESTION DES SOUS-DOSSIERS ---
+            
+            # Utiliser le chemin relatif complet du fichier (ex: 'css/style.css' ou 'index.html')
+            # Nous faisons confiance à file_storage.filename pour contenir le chemin relatif
+            filename_with_path = file_storage.filename.strip() 
+            
+            # Sécurité: normaliser le chemin pour éviter les traversées de dossiers (ex: '../')
+            safe_relative_path = os.path.normpath(filename_with_path)
+            
+            # Construction du chemin local complet dans le dossier temporaire
+            local_path = os.path.join(local_temp_repo_path, safe_relative_path)
+            
+            # S'assurer que le SOUS-DOSSIER local existe avant de sauvegarder le fichier
+            # os.path.dirname('temp/css/style.css') -> 'temp/css'
+            os.makedirs(os.path.dirname(local_path), exist_ok=True)
+            
+            # Sauvegarder l'objet FileStorage dans le chemin local
+            file_storage.save(local_path)
+            local_file_paths.append(local_path)
+            
+            # --- FIN DE LA CORRECTION ---
+
+        # 3. Effectuer le téléversement atomique du dossier local vers HF
+        path_in_repo = f"{user_id}/{repo_slug}"
+
+        commit_message_full = (commit_message.strip() if commit_message else "Ajout de fichiers via upload")
+        if commit_description:
+            commit_message_full += f"\n\n{commit_description}"
+            
+        api.upload_folder(
+            folder_path=local_temp_repo_path,
+            repo_id=repo_id,
+            path_in_repo=path_in_repo,
+            repo_type="dataset", 
+            # Utilise 'commit_message_full' pour le titre et la description
+            commit_message=commit_message_full, 
+            # Laisse 'delete_old_files' désactivé pour ne pas supprimer les fichiers existants non inclus dans l'upload actuel
+            revision=branch # Cible la bonne branche (Git-like)
+        )
+        
+        # 4. Nettoyage
+        # On supprime le dossier temporaire de l'utilisateur/repo, mais pas TEMP_UPLOAD_DIR
+        shutil.rmtree(local_temp_repo_path)
+        
+        message = f"Téléversement réussi de {len(files)} fichiers (avec sous-dossiers si présents) vers le dépôt '{repo_slug}'."
+        logger.info(message)
+        return True, message
+
+    except HfHubHTTPError as e:
+        logger.error(f"Erreur API Hugging Face lors de l'upload pour {repo_slug}: {e}")
+        return False, f"Échec du téléversement Hugging Face (vérifiez les permissions ou la branche) : {e.response.text.splitlines()[0]}"
+    except Exception as e:
+        logger.error(f"Erreur inconnue lors du téléversement pour {repo_slug}: {e}")
+        # L'erreur de l'argument manquant peut être capturée ici
+        return False, f"Erreur interne lors du téléversement : {str(e)}"
+    finally:
+        # S'assurer que le dossier temporaire est toujours nettoyé, même en cas d'erreur
+        if os.path.exists(local_temp_repo_path):
+            shutil.rmtree(local_temp_repo_path)
+
+def save_json_file_to_hf(
+    file_path: str,
+    data: Dict,
+    commit_message: str,
+    repo_id: Optional[str] = None
+) -> tuple[bool, str]:
+    """
+    Encode les données en JSON, les commite et les enregistre sur Hugging Face.
+    """
+    if not repo_id:
+        return False, "Erreur de configuration: Repository Hugging Face non défini."
+
+    try:
+        updated_content = json.dumps(data, indent=4).encode('utf-8')
+        updated_file = BytesIO(updated_content)
+
+        api.upload_file(
+            path_or_fileobj=updated_file,
+            path_in_repo=file_path,
+            repo_id=repo_id,
+            repo_type="dataset",
+            commit_message=commit_message
+        )
+        
+        logger.info(f"Fichier JSON mis à jour sur HF à {file_path}.")
+        return True, "Fichier JSON mis à jour avec succès sur Hugging Face."
+        
+    except Exception as e:
+        logger.error(f"Erreur lors de la mise à jour du JSON HF pour {file_path}: {e}")
+        return False, f"Échec de la mise à jour du JSON Hugging Face: {str(e)}"
+
+def get_user_repo_metadata(
+    user_id: str,
+    repo_id: Optional[str] = None
+) -> tuple[Optional[Dict], str]:
+    """
+    Charge les métadonnées de tous les dépôts d'un utilisateur depuis le fichier metadata.json sur HF.
+    """
+    repo_id = repo_id if repo_id else HF_DATASET_REPO_ID
+    if not repo_id:
+        return None, "Erreur de configuration: Repository Hugging Face non défini."
+
+    metadata_path = _get_user_metadata_path(user_id)
+    hf_file_path = f"datasets/{repo_id}/{metadata_path}"
+
+    try:
+        if not fs.exists(hf_file_path):
+            return None, f"Fichier de métadonnées non trouvé pour l'utilisateur {user_id}."
+
+        with fs.open(hf_file_path, "rb") as f:
+            content = f.read()
+        
+        metadata = json.loads(content.decode('utf-8'))
+        return metadata, "Métadonnées chargées avec succès."
+        
+    except Exception as e:
+        logger.error(f"Erreur lors du chargement des métadonnées HF pour {user_id}: {e}")
+        return None, f"Échec du chargement des métadonnées: {str(e)}"
+
+def initialize_user_hf_folder(
+    user_id: str,
+    repo_id: Optional[str] = None
+) -> tuple[bool, str]:
+    """
+    Crée le dossier principal de l'utilisateur (user_id/) sur HF et un fichier de métadonnées initial (metadata.json).
+    Ceci est le 'dossier principal' qui stocke les informations de l'utilisateur.
+    """
+    repo_id = repo_id if repo_id else HF_DATASET_REPO_ID
+    if not repo_id:
+        return False, "Erreur de configuration: Repository Hugging Face non défini."
+        
+    base_path = _get_user_base_path(user_id)
+    metadata_path = _get_user_metadata_path(user_id)
+    
+    initial_metadata = {
+        "user_ref": user_id,
+        "repos": []
+    }
+    
+    try:
+        metadata_content = json.dumps(initial_metadata, indent=4).encode('utf-8')
+        metadata_file = BytesIO(metadata_content)
+
+        commit_url = api.upload_file(
+            path_or_fileobj=metadata_file,
+            path_in_repo=metadata_path,
+            repo_id=repo_id,
+            repo_type="dataset",
+            commit_message=f"Initialisation du dossier et des métadonnées pour l'utilisateur {user_id}"
+        )
+        
+        logger.info(f"Dossier HF initialisé pour l'utilisateur {user_id} à {base_path}. Commit: {commit_url}")
+        return True, "Dossier et métadonnées HF initialisés."
+    except Exception as e:
+        logger.error(f"Échec de l'initialisation du dossier HF pour {user_id}: {e}")
+        return False, f"Échec de l'initialisation Hugging Face: {str(e)}"
+
+def update_user_repo_metadata(
+    user_id: str,
+    new_repo_data: Dict,
+    repo_id: Optional[str] = None
+) -> tuple[bool, str]:
+    """
+    Met à jour le fichier metadata.json de l'utilisateur en ajoutant ou remplaçant un dépôt.
+    """
+    repo_id = repo_id if repo_id else HF_DATASET_REPO_ID
+    if not repo_id:
+        return False, "Erreur de configuration: Repository Hugging Face non défini."
+
+    metadata_path = _get_user_metadata_path(user_id)
+    
+    # 1. Charger les métadonnées actuelles ou initialiser si manquant
+    current_metadata, message = get_user_repo_metadata(user_id)
+    
+    if current_metadata is None:
+        logger.warning(f"Tentative de chargement des métadonnées pour {user_id} échouée: {message}. Tentative d'initialisation.")
+        success_init, init_message = initialize_user_hf_folder(user_id)
+        
+        if not success_init:
+            return False, f"Impossible de charger OU d'initialiser les métadonnées: {init_message}"
+
+        # Recharger après initialisation
+        current_metadata, _ = get_user_repo_metadata(user_id)
+        if current_metadata is None:
+            return False, "Impossible de charger ou d'initialiser les métadonnées."
+
+    # 2. Mettre à jour la liste des dépôts
+    repos = current_metadata.get("repos", [])
+    
+    # Remplacer l'entrée existante si le FIELD_DEPLOY_ID correspond (mise à jour ou nouvel ajout)
+    deploy_id = new_repo_data.get('FIELD_DEPLOY_ID')
+    repos = [repo for repo in repos if repo.get('FIELD_DEPLOY_ID') != deploy_id]
+    
+    repos.append(new_repo_data)
+    current_metadata["repos"] = repos
+
+    # 3. Écrire et téléverser le fichier mis à jour
+    try:
+        updated_content = json.dumps(current_metadata, indent=4).encode('utf-8')
+        updated_file = BytesIO(updated_content)
+
+        api.upload_file(
+            path_or_fileobj=updated_file,
+            path_in_repo=metadata_path,
+            repo_id=repo_id,
+            repo_type="dataset",
+            commit_message=f"Mise à jour des métadonnées: Ajout/Modification du dépôt {deploy_id} par l'utilisateur {user_id}"
+        )
+        
+        logger.info(f"Métadonnées HF mises à jour pour l'utilisateur {user_id}. Dépôt {deploy_id} ajouté.")
+        return True, "Métadonnées du dépôt mises à jour avec succès sur Hugging Face."
+        
+    except Exception as e:
+        logger.error(f"Erreur lors de la mise à jour des métadonnées HF pour {user_id}: {e}")
+        return False, f"Échec de la mise à jour des métadonnées Hugging Face: {str(e)}"
+
+
+
+def create_empty_repo_folder_on_hf(
+    repo_slug: str,
+    user_id: str,
+    repo_id: Optional[str] = None
+) -> tuple[bool, str]:
+    """
+    Crée le sous-dossier du dépôt (user_id/repo_slug/) sur le Dataset Hugging Face
+    en y ajoutant un fichier README.md initial.
+    """
+    repo_id = repo_id if repo_id else HF_DATASET_REPO_ID
+    if not repo_id:
+        return False, "Erreur de configuration: Repository Hugging Face non défini."
+
+    readme_content = f"# Dépôt {repo_slug}\n\nBienvenue sur votre dépôt GitForge, hébergé sur Mailix.\n\nCommencez par ajouter ou créer des fichiers."
+    path_in_repo = f"{user_id}/{repo_slug}/README.md"
+    
+    try:
+        # Utilisation de HfApi.upload_file pour créer un fichier unique, ce qui crée le dossier
+        commit_url = api.upload_file(
+            path_or_fileobj=readme_content.encode('utf-8'),
+            path_in_repo=path_in_repo,
+            repo_id=repo_id,
+            repo_type="dataset",
+            commit_message=f"feat: Initialisation du dépôt '{repo_slug}' pour l'utilisateur {user_id}"
+        )
+        
+        logger.info(f"Dépôt initialisé avec succès pour {user_id}/{repo_slug}. Commit: {commit_url}")
+        return True, f"Dépôt initialisé avec succès sur Hugging Face. Chemin: {user_id}/{repo_slug}"
+
+    except Exception as e:
+        logger.error(f"Échec de l'initialisation du dépôt HF pour {repo_slug} par {user_id}: {e}")
+        return False, f"Échec de l'initialisation Hugging Face: {str(e)}"
+
+
+def list_repo_files_from_hf(
+    repo_slug: str,
+    user_id: str,
+    repo_id: Optional[str] = None
+) -> tuple[list[Dict], str]:
+    """
+    Liste tous les fichiers et dossiers dans le chemin spécifique (user_id/repo_slug) 
+    du Dataset Hugging Face, incluant le temps écoulé (time_ago).
+    """
+    repo_id = repo_id if repo_id else HF_DATASET_REPO_ID
+    if not repo_id:
+        return [], "Erreur de configuration: Repository Hugging Face non défini."
+
+    # Le chemin dans le repo est 'user_id/repo_slug'
+    path_to_repo = f"{user_id}/{repo_slug}"
+
+    try:
+        # Utiliser HfFileSystem pour lister le contenu du dossier
+        # 'detail=True' est essentiel pour obtenir 'last_modified'
+        items = fs.ls(f"datasets/{repo_id}/{path_to_repo}", detail=True)
+        
+        file_list = []
+        for item in items:
+            # item est un dictionnaire avec 'name', 'type', 'size', 'last_modified', etc.
+            # On ignore le nom du dossier racine pour l'affichage utilisateur
+            file_name = item['name'].split('/')[-1]
+
+            # Ignorer les dossiers et les fichiers système cachés (.DS_Store, .gitattributes, etc.)
+            if item['type'] == 'directory' or file_name.startswith('.'):
+                 # Inclure les dossiers pourrait être une future amélioration
+                 continue
+
+            last_modified_datetime = item.get('last_modified', 'N/A')
+            
+            # --- AJOUT DE LA LOGIQUE DE TEMPS ÉCOULÉ ---
+            time_ago_string = 'N/A'
+            if last_modified_datetime != 'N/A':
+                # S'assurer que la chaîne est une date/heure valide avant de la traiter
+                try:
+                    time_ago_string = _format_time_ago(last_modified_datetime)
+                except Exception:
+                    logger.warning(f"Impossible de formater la date/heure: {last_modified_datetime}")
+                    time_ago_string = 'N/A'
+            # --------------------------------------------
+
+            file_list.append({
+                "name": file_name,
+                "path": item['name'], # Chemin complet pour référence interne
+                "size": item.get('size', 0),
+                "type": "file", # Liste seulement les fichiers
+                "last_modified": last_modified_datetime, # Conserver la date/heure complète
+                "time_ago": time_ago_string # <-- NOUVEAU CHAMP
+            })
+            
+        logger.info(f"Liste des fichiers récupérée pour {path_to_repo} ({len(file_list)} fichiers).")
+        return file_list, "Liste des fichiers récupérée avec succès."
+
+    except HfHubHTTPError as e:
+        if "404" in str(e):
+            # Le dossier n'existe pas encore
+            return [], f"Le dépôt '{repo_slug}' n'a pas encore de fichiers sur Hugging Face (404)."
+        logger.error(f"Erreur HTTP HF lors de la liste des fichiers pour {path_to_repo}: {e}")
+        return [], f"Erreur Hugging Face: {str(e)}"
+    except Exception as e:
+        logger.error(f"Erreur inconnue lors de la liste des fichiers HF pour {path_to_repo}: {e}")
+        return [], f"Erreur inconnue lors de l'accès à Hugging Face: {str(e)}"
+
+# Nom du fichier de métadonnées de l'utilisateur dans son dossier principal
+METADATA_FILE_NAME = "user_repo_metadata.json"
+
+
+def get_file_content_from_hf(
+    file_path_in_repo: str,
+    repo_id: Optional[str] = None
+) -> tuple[Optional[str], str]:
+    """
+    Récupère le contenu brut d'un fichier spécifique depuis Hugging Face.
+
+    :param file_path_in_repo: Le chemin complet du fichier dans le repo HF, 
+                              incluant user_id/repo_slug/nom_fichier.ext.
+    :param repo_id: L'ID du repo HF (Dataset).
+    :return: (Contenu du fichier: Optional[str], Message: str)
+    """
+    repo_id = repo_id if repo_id else HF_DATASET_REPO_ID
+    if not repo_id:
+        return None, "Erreur de configuration: Repository Hugging Face non défini."
+        
+    hf_file_path = f"datasets/{repo_id}/{file_path_in_repo}"
+    
+    try:
+        if not fs.exists(hf_file_path):
+            return None, f"Fichier non trouvé sur Hugging Face: {file_path_in_repo}"
+
+        # Utiliser fs.open pour lire le contenu
+        with fs.open(hf_file_path, "rb") as f:
+            content = f.read()
+        
+        # Tenter le décodage en UTF-8 pour le contenu texte (ex: README.md)
+        return content.decode('utf-8'), "Contenu du fichier chargé avec succès."
+        
+    except HfHubHTTPError as e:
+        if "404" in str(e):
+            return None, f"Fichier non trouvé sur Hugging Face (404): {file_path_in_repo}"
+        logger.error(f"Erreur HTTP HF lors de la lecture de {file_path_in_repo}: {e}")
+        return None, f"Erreur Hugging Face: {str(e)}"
+    except Exception as e:
+        logger.error(f"Erreur inconnue lors de la lecture de {file_path_in_repo}: {e}")
+        return None, f"Échec de la lecture du fichier: {str(e)}"
+
+
+def load_json_file_from_hf(
+    file_path: str,
+    repo_id: Optional[str] = None
+) -> tuple[Optional[Dict], str]:
+    """
+    Charge un fichier JSON spécifique depuis Hugging Face et le décode.
+    Utilisé pour charger le fichier prs.json.
+    """
+    # Si repo_id n'est pas fourni, on assume le repo principal si le chemin le permet, 
+    # mais il sera plus sûr de le passer explicitement (PULL_REQUESTS_HF_REPO_ID)
+    if not repo_id:
+        # Dans le contexte des PR, on devrait avoir un repo_id dédié
+        return None, "Erreur de configuration: Repository Hugging Face non défini."
+
+    hf_file_path = f"datasets/{repo_id}/{file_path}"
+
+    try:
+        if not fs.exists(hf_file_path):
+            # C'est un cas normal pour un dépôt sans PR encore créé
+            return None, f"Fichier JSON non trouvé (normal si première PR): {file_path}"
+
+        with fs.open(hf_file_path, "rb") as f:
+            content = f.read()
+        
+        metadata = json.loads(content.decode('utf-8'))
+        return metadata, "Fichier JSON chargé avec succès."
+        
+    except Exception as e:
+        logger.error(f"Erreur lors du chargement du JSON HF depuis {hf_file_path}: {e}")
+        return None, f"Échec du chargement du JSON: {str(e)}"
+
+# Renommage et adaptation de la fonction pour la rendre générique
+def save_file_content_to_hf(
+    user_id: str,
+    repo_slug: str,
+    file_path: str,
+    file_content: str, # Le contenu du fichier, peu importe le type (string)
+    commit_message: str,
+    # repo_id est l'ID du dépôt conteneur global (ex: 'Mindus/Nexus-Data')
+    repo_id: Optional[str] = None, 
+    repo_type: str = "dataset",
+    branch: str = "main" # <-- Argument conservé dans la signature de la fonction
+) -> tuple[bool, str]:
+    """
+    Crée un nouveau fichier ou met à jour un fichier existant dans un dépôt 
+    spécifié (user_id/repo_slug) avec le contenu string fourni.
+    """
+    
+    if not repo_id:
+        # Ceci suppose que HF_DATASET_REPO_ID est défini dans votre configuration globale
+        try:
+            from config import HF_DATASET_REPO_ID
+            repo_id = HF_DATASET_REPO_ID
+        except ImportError:
+            return False, "Erreur de configuration: Repository Hugging Face non défini."
+
+    # Construction du chemin complet cible: {user_id}/{repo_slug}/{file_path}
+    path_in_repo = f"{user_id}/{repo_slug}/{file_path}"
+
+    try:
+        # 1. Convertir le contenu string en objet BytesIO pour l'API
+        updated_content = file_content.encode('utf-8')
+        updated_file = BytesIO(updated_content)
+
+        # 2. Appel de l'API pour commiter le fichier
+        # CORRECTION : Le paramètre 'branch' est retiré de l'appel pour compatibilité avec
+        # les anciennes versions de la librairie huggingface_hub qui n'ont pas cet argument.
+        api.upload_file(
+            path_or_fileobj=updated_file,
+            path_in_repo=path_in_repo,
+            repo_id=repo_id,
+            repo_type=repo_type,
+            commit_message=commit_message,
+            # branch=branch, <-- RETIRÉ
+        )
+        
+        logging.info(f"Fichier '{path_in_repo}' commité avec succès sur HF.")
+        return True, f"Fichier '{file_path}' sauvegardé avec succès dans le dépôt '{repo_slug}'."
+        
+    except HfHubHTTPError as e:
+        logging.error(f"Erreur de l'API HF lors de la sauvegarde de {path_in_repo}: {e}")
+        return False, f"Erreur de l'API Hugging Face: {str(e)}"
+    except Exception as e:
+        logging.error(f"Erreur inattendue lors de la sauvegarde de {path_in_repo}: {e}")
+        return False, f"Échec de la sauvegarde: {str(e)}"
+
+
+def get_diff_between_branches(
+    repo_slug: str,
+    user_id: str,
+    branch_a: str, # Source
+    branch_b: str, # Target
+    repo_id: Optional[str] = None
+) -> tuple[Optional[Dict], str]:
+    """
+    (Placeholder) Calcule le 'diff' entre deux branches d'un dépôt utilisateur.
+    Nécessite une fonctionnalité avancée de l'API Hugging Face ou un clonage/diff local.
+    """
+    # L'API HfHub ne fournit pas de 'diff' simple entre branches.
+    # Ceci est un DÉMONSTRATEUR de la signature requise.
+    
+    # Le chemin dans le repo est 'user_id/repo_slug'
+    target_repo_id = repo_id if repo_id else HF_DATASET_REPO_ID
+    
+    # TODO: Implémentation réelle pour calculer/récupérer le diff
+    # Pour l'instant, on retourne un placeholder.
+    return None, f"Fonction de diff non implémentée (simulation requise pour {branch_a} vs {branch_b})."
+
+
+def check_for_conflicts(
+    repo_slug: str,
+    user_id: str,
+    source_branch: str,
+    target_branch: str,
+    repo_id: Optional[str] = None
+) -> tuple[bool, List[str], str]:
+    """
+    (Placeholder) Simule une fusion pour vérifier les conflits.
+    """
+    # Mêmes contraintes que get_diff_between_branches.
+    # Ceci est un DÉMONSTRATEUR de la signature requise.
+
+    return True, [], "Vérification de conflit non implémentée. Supposons 'pas de conflit' pour l'ébauche."
+
+
+def execute_merge_commit(
+    repo_slug: str,
+    user_id: str,
+    source_branch: str,
+    target_branch: str,
+    message: str,
+    committer_id: str,
+    repo_id: Optional[str] = None
+) -> tuple[bool, str]:
+    """
+    Exécute la fusion de la branche source vers la branche cible en utilisant l'API Hugging Face.
+    
+    :param repo_slug: Le slug du dépôt de l'utilisateur.
+    :param user_id: L'ID de l'utilisateur propriétaire.
+    :param source_branch: La branche source à fusionner (ex: feature/branch).
+    :param target_branch: La branche cible (ex: main).
+    :param message: Le message de commit pour la fusion.
+    :param committer_id: L'ID de l'utilisateur qui exécute la fusion.
+    :param repo_id: L'ID du dépôt HF (Dataset) si différent du principal.
+    :return: (Statut de succès: bool, Message: str)
+    """
+    repo_id = repo_id if repo_id else HF_DATASET_REPO_ID
+    if not repo_id:
+        return False, "Erreur de configuration: HF_DATASET_REPO_ID manquant."
+
+    # L'ID complet du dépôt est toujours 'user_id/repo_slug' dans notre structure logique
+    target_repo_path = f"{user_id}/{repo_slug}"
+
+    try:
+
+        
+        logger.warning(f"Simulating Git Merge for {target_repo_path}: {source_branch} -> {target_branch}. Requires actual Git implementation or dedicated API endpoint.")
+        
+
+        merge_success_msg = f"Fusion Git simulée entre {source_branch} et {target_branch} pour {target_repo_path}."
+        
+        # 2. Nettoyage : Suppression de la branche source (comportement typique après PR merge)
+        # Note: Cette étape est optionnelle pour le merge mais typique pour le nettoyage d'une PR.
+        api.delete_branch(
+            repo_id=target_repo_path,
+            repo_type="dataset",
+            branch=source_branch
+        )
+        logger.info(f"Branche source '{source_branch}' supprimée pour le dépôt {target_repo_path}.")
+        
+        return True, f"Fusion simulée et nettoyage réussi. {merge_success_msg}"
+
+    except HfHubHTTPError as e:
+        if "404" in str(e):
+            return False, f"Erreur 404: Dépôt ou branche non trouvée sur Hugging Face. {e}"
+        # Gérer spécifiquement les conflits si l'API renvoie une erreur pertinente
+        elif "conflict" in str(e).lower():
+            return False, f"Échec de la fusion : Conflit détecté par le service Hugging Face. {e}"
+        return False, f"Erreur API Hugging Face lors de la fusion : {e}"
+    except Exception as e:
+        logger.error(f"Erreur inattendue lors de l'exécution du merge pour {target_repo_path}: {e}")
+        return False, f"Erreur inattendue lors de la fusion : {str(e)}"
+
+def commit_file_to_hf(
+    repo_slug: str,
+    user_id: str,
+    file_path: str, # Le chemin du fichier dans le repo de l'utilisateur (ex: 'index.html', 'css/style.css')
+    file_content: str,
+    commit_message: str,
+    repo_type: str = "dataset",
+    branch: str = "main" # On simplifie en commitant directement sur main pour l'instant
+) -> tuple[bool, str]:
+    """
+    Crée ou met à jour un fichier dans un dépôt Hugging Face avec un message de commit.
+
+    :param repo_slug: Le nom du dépôt (ex: 'mailix').
+    :param user_id: L'ID de l'utilisateur (pour le chemin principal dans le dataset).
+    :param file_path: Le chemin relatif du fichier dans le dépôt.
+    :param file_content: Le contenu (string) du fichier à enregistrer.
+    :param commit_message: Le message de commit.
+    :param repo_type: Le type de dépôt (par défaut 'dataset' pour la structure actuelle).
+    :param branch: La branche cible (par défaut 'main').
+    :return: Un tuple (succès: bool, message: str).
+    """
+    # Chemin complet du fichier dans le HF Dataset : user_id/repo_slug/file_path
+    hf_path = f"{user_id}/{repo_slug}/{file_path}"
+    
+    try:
+        # L'API Hub de HF utilise `upload_file` (ou `upload_folder`) pour
+        # créer ou remplacer un fichier existant. Nous utilisons BytesIO
+        # pour traiter le contenu comme un fichier sans l'écrire sur disque local.
+        file_data = BytesIO(file_content.encode('utf-8'))
+        
+        # Le nom du fichier est requis pour HfApi.upload_file.
+        # Ici, nous utilisons le nom de la variable `file_path` qui est déjà
+        # le chemin complet dans le repo HF pour la fonction
+        
+        api.upload_file(
+            path_or_fileobj=file_data,  # <-- C'EST LA CORRECTION
+            path_in_repo=hf_path,   # Chemin complet cible dans le repo HF Dataset
+            repo_id=HF_DATASET_REPO_ID, # ID du dataset global qui contient tous les utilisateurs/repos
+            repo_type=repo_type,
+            commit_message=commit_message,
+            branch=branch,
+        )
+        
+        logger.info(f"Fichier '{hf_path}' commité avec succès sur HF.")
+        return True, f"File '{file_path}' successfully committed."
+
+    except HfHubHTTPError as e:
+        logger.error(f"HF API Error during commit for {hf_path}: {e}")
+        return False, f"Hugging Face API Error: Failed to commit file. {e}"
+    except Exception as e:
+        logger.error(f"Unexpected Error during commit for {hf_path}: {e}")
+        return False, f"Unexpected Error: {e}"
+
+def delete_file_from_hf_repo(
+    repo_slug: str,
+    user_id: str,
+    file_path: str,  # Le chemin relatif du fichier dans le dépôt
+    commit_message: str,
+    repo_type: str = "dataset",
+    branch: str = "main"
+) -> tuple[bool, str]:
+    """
+    Supprime un fichier spécifique d'un dépôt Hugging Face.
+
+    :param repo_slug: Le slug du dépôt.
+    :param user_id: L'ID de l'utilisateur.
+    :param file_path: Le chemin relatif complet du fichier à supprimer (ex: user_id/repo_slug/fichier.ext).
+    :param commit_message: Le message de commit pour la suppression.
+    :return: Un tuple (succès: bool, message: str).
+    """
+    repo_id = HF_DATASET_REPO_ID # S'assurer que la variable globale est accessible
+
+    if not repo_id:
+        # Utiliser `logger.error` ici est une bonne pratique
+        logger.error("Erreur de configuration: Repository Hugging Face non défini (HF_DATASET_REPO_ID manquant).")
+        return False, "Erreur de configuration: Repository Hugging Face non défini."
+
+    # --- CORRECTION APPLIQUÉE ---
+    # Le chemin 'file_path' (qui provient de votre fonction de listage)
+    # est utilisé directement car il contient déjà le préfixe complet nécessaire
+    # (par exemple : 'a6ea61c8-951a-413a-ba9d-7365d83fbd4d/github/app.py')
+    hf_path = file_path # <-- MODIFICATION CLÉ
+    # Si le frontend n'envoyait que 'app.py' ou le chemin relatif AU SEIN du repo,
+    # L'ancienne ligne (f"{user_id}/{repo_slug}/{file_path}") aurait été correcte.
+    # Mais dans votre cas, 'file_path' est déjà le chemin complet.
+
+    try:
+        # L'API HfHub utilise 'delete_file' pour supprimer un fichier.
+        api.delete_file(
+            path_in_repo=hf_path,    # Chemin complet du fichier cible
+            repo_id=repo_id,         # ID du dataset global (ernestmindres/ernestmind_user_data)
+            repo_type=repo_type,
+            commit_message=commit_message,
+            # branch=branch, # Peut être laissé pour plus de robustesse si la branche n'est pas 'main'
+        )
+        
+        logger.info(f"Fichier '{hf_path}' supprimé avec succès sur HF.")
+        return True, f"File '{file_path}' successfully deleted from repository '{repo_slug}'."
+
+    except HfHubHTTPError as e:
+        # Gérer le cas où le fichier n'existe pas (404) ou autre erreur d'API
+        logger.error(f"HF API Error during file deletion for {hf_path}: {e}")
+        # Renvoyer l'erreur spécifique de Hugging Face au client
+        return False, f"Hugging Face API Error: Failed to delete file. {e}"
+    except Exception as e:
+        logger.error(f"Unexpected Error during file deletion for {hf_path}: {e}")
+        return False, f"Unexpected Error: {e}"
+
+
+def save_application_json_to_hf(application_data: Dict, application_id: str, commit_message: Optional[str] = None) -> (bool, str):
+    """
+    Sauvegarde les données d'application JSON dans le dépôt HF (IMAGE_STORAGE_HF_REPO_ID).
+    Structure du chemin : json_applications/{application_id}.json
+    """
+    if not IMAGE_STORAGE_HF_REPO_ID:
+        return False, "IMAGE_STORAGE_HF_REPO_ID n'est pas configuré. Veuillez vérifier config.py et les variables d'environnement."
+
+    repo_id = IMAGE_STORAGE_HF_REPO_ID
+    # Chemin complet dans le dépôt
+    hf_path = f"json_applications/{application_id}.json"
+
+    # Convertir les données en JSON string
+    # ensure_ascii=False permet de gérer correctement les caractères français (accents)
+    json_content = json.dumps(application_data, indent=4, ensure_ascii=False)
+    
+    commit_message = commit_message or f"Ajout des données de candidature: {application_id}"
+
+    try:
+        # Utiliser 'upload_file' avec 'data' (contenu bytes ou string)
+        api.upload_file(
+            path_in_repo=hf_path,
+            path_or_fileobj=json_content.encode('utf-8'), # L'encodage est crucial pour les données
+            repo_id=repo_id,
+            repo_type="dataset", 
+            commit_message=commit_message,
+        )
+
+        logger.info(f"Fichier JSON '{hf_path}' sauvegardé avec succès sur HF dans {repo_id}.")
+        return True, f"Données d'application '{application_id}' sauvegardées avec succès."
+
+    except HfHubHTTPError as e:
+        logger.error(f"Erreur API HF lors de la sauvegarde du JSON: {e}")
+        return False, f"Erreur lors de la sauvegarde du JSON: {str(e)}"
+    except Exception as e:
+        logger.error(f"Erreur inattendue lors de la sauvegarde du JSON: {e}")
+        return False, f"Erreur inattendue: {str(e)}"
+
+
+def upload_application_document_to_hf(file_storage_obj: FileStorage, application_id: str, file_extension: str, commit_message: Optional[str] = None) -> (bool, str):
+    """
+    Téléverse un fichier PDF/DOCX dans le dépôt HF dédié au stockage (IMAGE_STORAGE_HF_REPO_ID).
+    Structure du chemin : document_applications/{application_id}{file_extension}
+    """
+    if not IMAGE_STORAGE_HF_REPO_ID:
+        return False, "IMAGE_STORAGE_HF_REPO_ID n'est pas configuré. Veuillez vérifier config.py et les variables d'environnement."
+
+    repo_id = IMAGE_STORAGE_HF_REPO_ID
+    # Chemin complet dans le dépôt
+    hf_path = f"document_applications/{application_id}{file_extension}"
+    
+    commit_message = commit_message or f"Téléversement du document de candidature: {application_id}{file_extension}"
+    temp_file_path = None # Initialisation pour le nettoyage
+
+    try:
+        # 1. Créer un chemin temporaire pour le fichier
+        # TEMP_UPLOAD_DIR est supposé être défini (ex: "/tmp/hf_uploads")
+        os.makedirs(TEMP_UPLOAD_DIR, exist_ok=True)
+        # Utilisation d'un UUID pour s'assurer que le nom du fichier temporaire est unique
+        temp_file_path = os.path.join(TEMP_UPLOAD_DIR, f"temp_{application_id}_{uuid.uuid4()}{file_extension}")
+        
+        # 2. Sauvegarder l'objet FileStorage sur le disque
+        file_storage_obj.save(temp_file_path)
+
+        # 3. Téléverser le fichier depuis le chemin temporaire
+        api.upload_file(
+            path_in_repo=hf_path,
+            path_or_fileobj=temp_file_path, 
+            repo_id=repo_id,
+            repo_type="dataset", 
+            commit_message=commit_message,
+        )
+        
+        # 4. Nettoyer le fichier temporaire
+        if os.path.exists(temp_file_path):
+            os.remove(temp_file_path)
+
+        logger.info(f"Fichier '{hf_path}' téléversé avec succès sur HF dans {repo_id}.")
+        return True, f"Document d'application '{file_storage_obj.filename}' téléversé avec succès."
+
+    except HfHubHTTPError as e:
+        logger.error(f"Erreur API HF lors du téléversement du document: {e}")
+        return False, f"Erreur lors du téléversement du document: {str(e)}"
+    except Exception as e:
+        logger.error(f"Erreur inattendue lors du téléversement du document: {e}")
+        return False, f"Erreur inattendue: {str(e)}"
+    finally:
+        # Nettoyage final en cas d'erreur ou de succès
+        if temp_file_path and os.path.exists(temp_file_path):
+            os.remove(temp_file_path)
+
+
+def delete_repo_folder_from_hf(
+    repo_slug: str,
+    user_id: str,
+    deploy_id: str, # L'identifiant unique utilisé dans metadata.json
+    commit_message: Optional[str] = None,
+    repo_id: Optional[str] = None
+) -> tuple[bool, str]:
+    """
+    Supprime récursivement un dossier de dépôt complet (user_id/repo_slug) sur Hugging Face
+    et met à jour le fichier metadata.json de l'utilisateur.
+
+    :param repo_slug: Le slug du dépôt à supprimer.
+    :param user_id: L'ID de l'utilisateur propriétaire.
+    :param deploy_id: L'ID utilisé pour identifier le dépôt dans les métadonnées.
+    :return: (Statut de succès: bool, Message: str)
+    """
+    repo_id = repo_id if repo_id else HF_DATASET_REPO_ID
+    if not repo_id:
+        return False, "Erreur de configuration: HF_DATASET_REPO_ID manquant."
+
+    path_in_repo = f"{user_id}/{repo_slug}"
+    commit_msg = commit_message or f"Suppression du dépôt complet '{repo_slug}' et du dossier '{path_in_repo}'"
+
+    try:
+        # 1. Suppression du dossier sur Hugging Face (suppression récursive)
+        # Note: L'API HfApi ne fournit pas de 'delete_folder' direct qui commite.
+        # On peut utiliser delete_repo, mais si c'est un sous-dossier, l'approche 'git-like'
+        # consiste à utiliser 'upload_folder' avec une liste de fichiers vides ou 
+        # une autre méthode de suppression de sous-dossier.
+        # La meilleure façon de supprimer un dossier *dans un dataset existant* est 
+        # d'utiliser api.delete_folder (si disponible) ou d'utiliser une solution de contournement.
+        
+        # En utilisant HfApi, la méthode la plus fiable est delete_folder
+        api.delete_folder(
+            path_in_repo=path_in_repo,
+            repo_id=repo_id,
+            repo_type="dataset",
+            commit_message=commit_msg,
+        )
+        
+        logger.info(f"Dossier HF '{path_in_repo}' supprimé avec succès.")
+
+        # 2. Mise à jour des métadonnées de l'utilisateur
+        current_metadata, msg = get_user_repo_metadata(user_id, repo_id=repo_id)
+        if current_metadata:
+            repos = current_metadata.get("repos", [])
+            
+            # Filtrer le dépôt supprimé
+            new_repos = [repo for repo in repos if repo.get('FIELD_DEPLOY_ID') != deploy_id]
+            current_metadata["repos"] = new_repos
+
+            # Commiter la mise à jour des métadonnées
+            metadata_path = _get_user_metadata_path(user_id)
+            save_success, save_msg = save_json_file_to_hf(
+                file_path=metadata_path,
+                data=current_metadata,
+                commit_message=f"Nettoyage des métadonnées après suppression de dépôt {deploy_id}.",
+                repo_id=repo_id
+            )
+            
+            if not save_success:
+                logger.error(f"Échec de la mise à jour des métadonnées après suppression de {repo_slug}: {save_msg}")
+                # Le dossier est supprimé, mais les métadonnées ne le sont pas (erreur partielle)
+                return False, f"Dépôt supprimé, mais échec de la mise à jour des métadonnées: {save_msg}"
+                
+        else:
+            logger.warning(f"Métadonnées utilisateur {user_id} non trouvées ou inaccessibles après suppression du dépôt. Nettoyage des métadonnées ignoré.")
+
+        return True, f"Dépôt '{repo_slug}' et ses fichiers supprimés avec succès. Métadonnées mises à jour."
+
+    except HfHubHTTPError as e:
+        if "404" in str(e):
+            logger.warning(f"Tentative de suppression d'un dépôt non existant : {path_in_repo}. Passage au nettoyage des métadonnées.")
+            # Si le dossier n'existe pas, on procède quand même au nettoyage des métadonnées
+            # 2. Mise à jour des métadonnées de l'utilisateur (logique du 404)
+            current_metadata, msg = get_user_repo_metadata(user_id, repo_id=repo_id)
+            if current_metadata:
+                repos = current_metadata.get("repos", [])
+                new_repos = [repo for repo in repos if repo.get('FIELD_DEPLOY_ID') != deploy_id]
+                current_metadata["repos"] = new_repos
+
+                metadata_path = _get_user_metadata_path(user_id)
+                save_success, save_msg = save_json_file_to_hf(
+                    file_path=metadata_path,
+                    data=current_metadata,
+                    commit_message=f"Nettoyage des métadonnées après suppression du dépôt non trouvé {deploy_id}.",
+                    repo_id=repo_id
+                )
+                if save_success:
+                    return True, f"Le dépôt '{repo_slug}' n'existait pas, mais les métadonnées ont été nettoyées avec succès."
+                else:
+                    return False, f"Le dépôt n'existait pas, mais échec de la mise à jour des métadonnées: {save_msg}"
+            
+            return True, f"Le dépôt '{repo_slug}' n'existait pas et a été traité."
+
+        logger.error(f"Erreur API Hugging Face lors de la suppression de {path_in_repo}: {e}")
+        return False, f"Échec de la suppression Hugging Face: {str(e)}"
+    except Exception as e:
+        logger.error(f"Erreur inattendue lors de la suppression de {path_in_repo}: {e}")
+        return False, f"Erreur interne lors de la suppression du dépôt : {str(e)}"
+
+def update_repo_secrets_or_variables(
+    user_id: str,
+    repo_slug: str,
+    item_type: str, # 'secret' ou 'variable'
+    name: str,
+    value: str, # 'valeur'
+    description: Optional[str] = None
+) -> tuple[bool, str]:
+    """
+    Charge, met à jour (ajoute/remplace) un secret ou une variable, et sauvegarde le fichier JSON sur Hugging Face.
+    """
+    if item_type not in ['secret', 'variable']:
+        return False, "Type d'élément non valide. Doit être 'secret' ou 'variable'."
+        
+    is_secret = (item_type == 'secret')
+    
+    if is_secret:
+        file_path = _get_repo_secrets_path(user_id, repo_slug)
+        commit_message = f"Mise à jour du secret '{name}' pour le dépôt '{repo_slug}'."
+    else:
+        file_path = _get_repo_variables_path(user_id, repo_slug)
+        commit_message = f"Mise à jour de la variable '{name}' pour le dépôt '{repo_slug}'."
+
+    # 2. Charger les données actuelles
+    current_data, load_message = load_json_file_from_hf(
+        file_path=file_path,
+        repo_id=HF_DATASET_REPO_ID # Assumer le repo principal
+    )
+
+    # --- CORRECTION pour assurer la structure {"items": []} ---
+    if current_data is None:
+        if "non trouvé" in load_message:  
+            current_data = {"items": []}
+        else:
+            return False, f"Échec du chargement des données existantes: {load_message}"
+    
+    # Si le fichier existe mais n'est pas un dictionnaire, ou s'il manque la clé 'items'
+    if not isinstance(current_data, dict) or "items" not in current_data or not isinstance(current_data["items"], list):
+        # Ceci résout le problème de la perte des secrets/variables existantes.
+        # Si le fichier est chargé mais mal formaté (par exemple une liste ou un autre dict),
+        # on réinitialise la structure pour éviter la perte de données à la sauvegarde.
+        logger.warning(f"Le fichier {file_path} est dans un format inattendu. Réinitialisation de la liste des items.")
+        current_data = {"items": []}
+    # -------------------------------------------------------------
+
+    # 3. Préparer le nouvel élément (Aucun changement)
+    new_item = {
+        "name": name,
+        "description": description if description is not None else "",
+        "value": value,
+        "last_updated": datetime.utcnow().isoformat() 
+    }
+    
+    # 4. Mettre à jour la liste (remplacement par nom - La logique est CORRECTE)
+    items_list = current_data.get("items", []) # Maintenant items_list est garantie d'être la liste des éléments existants
+    
+    # Filtre les éléments existants pour supprimer celui portant le même nom (Update)
+    items_list = [item for item in items_list if item.get('name') != name]
+    
+    # Ajoute le nouvel élément ou l'élément mis à jour (Create/Update)
+    items_list.append(new_item)
+    current_data["items"] = items_list
+    
+    # 5. Sauvegarder le fichier mis à jour (Aucun changement)
+    success, save_message = save_json_file_to_hf(
+        file_path=file_path,
+        data=current_data,
+        commit_message=commit_message,
+        repo_id=HF_DATASET_REPO_ID
+    )
+
+    if success:
+        logger.info(f"Le {item_type} '{name}' a été mis à jour avec succès pour le dépôt '{repo_slug}'.")
+        return True, f"Le {item_type} '{name}' a été mis à jour avec succès pour le dépôt '{repo_slug}'."
+    else:
+        return False, f"Échec de la sauvegarde du {item_type} : {save_message}"
+
+# --- Nouvelle Fonction pour récupérer les Secrets ou Variables ---
+
+def get_repo_secrets_or_variables(
+    user_id: str,
+    repo_slug: str,
+    item_type: str # 'secret' ou 'variable'
+) -> tuple[List[Dict], str]:
+    """
+    Charge et retourne la liste des secrets ou variables pour un dépôt spécifique.
+    La valeur des secrets est masquée pour la sécurité.
+    """
+    if item_type not in ['secret', 'variable']:
+        return [], "Type d'élément non valide. Doit être 'secret' ou 'variable'."
+        
+    is_secret = (item_type == 'secret')
+    
+    if is_secret:
+        file_path = _get_repo_secrets_path(user_id, repo_slug)
+    else:
+        file_path = _get_repo_variables_path(user_id, repo_slug)
+    
+    current_data, load_message = load_json_file_from_hf(
+        file_path=file_path,
+        repo_id=HF_DATASET_REPO_ID
+    )
+
+    if current_data is None:
+        if "non trouvé" in load_message:
+            return [], f"Aucun {item_type} trouvé pour le dépôt '{repo_slug}'."
+        else:
+            logger.error(f"Erreur inattendue lors du chargement des {item_type}s : {load_message}")
+            return [], f"Échec du chargement des {item_type}s : {load_message}"
+
+    items_list = current_data.get("items", [])
+    
+    if is_secret:
+        # Masquer la valeur des secrets
+        sanitized_list = []
+        for item in items_list:
+            sanitized_item = item.copy()
+            sanitized_item['value'] = '***SECRET_VALUE_HIDDEN***'
+            sanitized_list.append(sanitized_item)
+        
+        logger.info(f"{len(sanitized_list)} secrets chargés avec succès pour {repo_slug} (valeurs masquées).")
+        return sanitized_list, f"{len(sanitized_list)} secrets chargés avec succès (valeurs masquées)."
+    else:
+        logger.info(f"{len(items_list)} variables chargées avec succès pour {repo_slug}.")
+        return items_list, f"{len(items_list)} variables chargées avec succès."
+
+# --- Nouvelle fonction pour la suppression (DELETE) ---
+def delete_repo_secret_or_variable(
+    user_id: str,
+    repo_slug: str,
+    item_type: str, # 'secret' ou 'variable'
+    name: str,
+) -> tuple[bool, str]:
+    """
+    Charge, supprime un secret ou une variable par son nom, et sauvegarde le fichier JSON sur Hugging Face.
+    """
+    if item_type not in ['secret', 'variable']:
+        return False, "Type d'élément non valide. Doit être 'secret' ou 'variable'."
+    
+    is_secret = (item_type == 'secret')
+    
+    if is_secret:
+        file_path = _get_repo_secrets_path(user_id, repo_slug)
+        commit_message = f"Suppression du secret '{name}' pour le dépôt '{repo_slug}'."
+    else:
+        file_path = _get_repo_variables_path(user_id, repo_slug)
+        commit_message = f"Suppression de la variable '{name}' pour le dépôt '{repo_slug}'."
+
+    # 1. Charger les données actuelles
+    current_data, load_message = load_json_file_from_hf(file_path=file_path, repo_id=HF_DATASET_REPO_ID)
+
+    if current_data is None or "items" not in current_data:
+        # Si le fichier n'existe pas ou est vide, l'élément n'existe pas de toute façon.
+        return True, f"Le {item_type} '{name}' a déjà été supprimé ou n'existe pas."
+
+    items_list = current_data.get("items", [])
+    
+    # 2. Filtrer la liste pour EXCLURE l'élément à supprimer
+    # On garde tous les éléments SAUF celui qui a le nom correspondant.
+    new_items_list = [item for item in items_list if item.get('name') != name]
+    
+    # Vérifier si quelque chose a été réellement supprimé
+    if len(new_items_list) == len(items_list):
+        return False, f"Le {item_type} '{name}' n'a pas été trouvé ou n'a pas pu être supprimé."
+        
+    current_data["items"] = new_items_list
+    
+    # 3. Sauvegarder la nouvelle liste
+    success, save_message = save_json_file_to_hf(
+        file_path=file_path,
+        data=current_data,
+        commit_message=commit_message,
+        repo_id=HF_DATASET_REPO_ID
+    )
+
+    if success:
+        return True, f"Le {item_type} '{name}' a été supprimé avec succès pour le dépôt '{repo_slug}'."
+    else:
+        return False, f"Échec de la sauvegarde après suppression : {save_message}"
+

a6ea61c8-951a-413a-ba9d-7365d83fbd4d/mayproject/huggingface_storage.py

@@ -0,0 +1,140 @@
+# huggingface_storage.py
+
+from werkzeug.datastructures import FileStorage # NÉCESSAIRE pour typer le paramètre 'files'
+import os
+import shutil
+import logging
+import json # <--- NOUVEL IMPORT
+from huggingface_hub import HfApi, HfFileSystem
+from huggingface_hub.utils import HfHubHTTPError
+from typing import Optional, Dict, List
+from io import BytesIO
+from config import HF_DATASET_REPO_ID # <--- S'assurer que ceci est importé
+
+logger = logging.getLogger(__name__)
+
+# --- Configuration Hugging Face ---
+HF_DATASET_REPO_ID = os.environ.get("HF_DATASET_REPO_ID")
+api = HfApi()
+fs = HfFileSystem()
+
+# --- Constantes pour le stockage utilisateur ---
+METADATA_FILE_NAME = "metadata.json"
+
+TEMP_UPLOAD_DIR = "/tmp/hf_uploads" # <-- AJOUTER/DÉPLACER ICI
+
+def delete_project_folder_from_hf(
+    deploy_id: str,
+    repo_id: Optional[str] = None
+) -> tuple[bool, str]:
+    """
+    Supprime un dossier (projet utilisateur) complet du Dataset Hugging Face.
+    """
+    repo_id = repo_id if repo_id else HF_DATASET_REPO_ID
+        
+    if not repo_id:
+        return False, "Erreur de configuration: Repository Hugging Face non défini."
+
+    try:
+        # delete_folder crée une seule commit pour la suppression du dossier.
+        commit_url = api.delete_folder(
+            path_in_repo=deploy_id,
+            repo_id=repo_id,
+            repo_type="dataset",
+            commit_message=f"Suppression du projet utilisateur ID: {deploy_id}"
+        )
+        
+        logger.info(f"Suppression réussie du projet {deploy_id}. URL de commit: {commit_url}")
+        return True, "Dossier de projet supprimé avec succès de Hugging Face."
+        
+    except Exception as e:
+        logger.error(f"Erreur inconnue lors de la suppression HF pour {deploy_id}: {e}")
+        # Si le dossier est déjà supprimé, HfHubHTTPError 404 est levée par delete_folder
+        if "404" in str(e):
+             return True, "Dossier non trouvé sur Hugging Face (déjà supprimé ou ID invalide)."
+        return False, f"Échec de la suppression Hugging Face: {str(e)}"
+
+def get_project_files_from_hf(
+    deploy_id: str,
+    local_target_path: str,
+    repo_id: Optional[str] = None
+) -> tuple[bool, str]:
+    """
+    Télécharge le dossier d'un projet depuis Hugging Face vers un dossier local.
+    """
+    repo_id = repo_id if repo_id else HF_DATASET_REPO_ID
+        
+    if not repo_id:
+        return False, "Erreur de configuration: Repository Hugging Face non défini."
+
+    try:
+        # Créer le dossier cible local
+        if os.path.exists(local_target_path):
+            shutil.rmtree(local_target_path)
+        os.makedirs(local_target_path, exist_ok=True)
+            
+        # Chemin complet vers le dossier du projet dans le dépôt Hugging Face
+        hf_folder_path = f"datasets/{repo_id}/{deploy_id}"
+        
+        if not fs.isdir(hf_folder_path):
+             return False, f"Projet non trouvé sur Hugging Face: {deploy_id}"
+             
+        # Télécharger récursivement le dossier du projet
+        # fs.get(chemin_distant, chemin_local)
+        fs.get(hf_folder_path, local_target_path, recursive=True)
+        
+        logger.info(f"Téléchargement réussi du projet {deploy_id} vers {local_target_path}.")
+        return True, "Dossier de projet téléchargé avec succès."
+        
+    except Exception as e:
+        logger.error(f"Erreur lors du téléchargement HF pour {deploy_id}: {e}")
+        return False, f"Échec du téléchargement Hugging Face: {str(e)}"
+
+
+def upload_project_folder_to_hf(
+    local_folder_path: str,
+    deploy_id: str,
+    repo_id: Optional[str] = None
+) -> tuple[bool, str, Optional[str]]:
+    """
+    Téléverse un dossier local (le projet utilisateur) vers un dossier spécifique
+    dans le Dataset Hugging Face, en une seule commit, en utilisant deploy_id comme path_in_repo.
+    """
+    repo_id = repo_id if repo_id else HF_DATASET_REPO_ID
+    
+    if not repo_id:
+        return False, "Erreur de configuration: Repository Hugging Face non défini (HF_DATASET_REPO_ID manquant).", None
+
+    try:
+        if not os.path.isdir(local_folder_path):
+            return False, f"Erreur: Le dossier local pour le déploiement ID '{deploy_id}' est introuvable.", None
+            
+        # path_in_repo est le chemin où les fichiers seront stockés dans le repo (le dossier du projet)
+        hf_folder_path = f"{deploy_id}" 
+        
+        logger.info(f"Début du téléversement de {local_folder_path} vers HF repo: {repo_id}/{hf_folder_path}")
+        
+        api.upload_folder(
+            folder_path=local_folder_path,
+            repo_id=repo_id,
+            path_in_repo=hf_folder_path,
+            repo_type="dataset", 
+            commit_message=f"Ajout du site web statique pour le projet ID: {deploy_id}",
+            # CORRECTION: Suppression de l'argument 'delete_old_files'
+            # (Le comportement par défaut de l'API moderne est de ne pas le supprimer sauf si explicitement listé)
+        )
+        
+        full_repo_path = f"https://huggingface.co/datasets/{repo_id}/tree/main/{deploy_id}"
+        logger.info(f"Téléversement HF réussi pour le projet {deploy_id}.")
+        
+        return True, "Téléversement vers Hugging Face réussi.", full_repo_path
+
+    except HfHubHTTPError as e:
+        error_message = f"Erreur API Hugging Face (vérifiez votre jeton d'API et les permissions): {e.response.text}"
+        logger.error(error_message)
+        return False, error_message, None
+    except Exception as e:
+        logger.error(f"Erreur lors du téléchargement HF pour {deploy_id}: {e}")
+        return False, f"Échec du téléchargement Hugging Face: {str(e)}", None
+
+

a6ea61c8-951a-413a-ba9d-7365d83fbd4d/mayproject/issue_routes.py

@@ -0,0 +1,214 @@
+# issue_routes.py
+
+from flask import Blueprint, request, jsonify, session
+from decorators import api_session_required 
+from typing import List, Dict, Any
+import logging
+
+# Importation des fonctions du backend Issues
+from issues_backend import (
+    create_issue,
+    load_all_issues_from_hf,
+    get_issue_by_id,
+    update_issue,
+    add_comment_to_issue,
+    load_all_user_issues
+)
+
+
+
+logger = logging.getLogger(__name__)
+
+# Création du Blueprint 'issue_bp'
+issue_bp = Blueprint('issue_bp', __name__)
+
+# ----------------------------------------------------------------------
+# ENDPOINTS API POUR LES ISSUES
+# ----------------------------------------------------------------------
+
+@issue_bp.route("/api/issue/create", methods=["POST"])
+@api_session_required
+def create_issue_route(client_user: Dict):
+    """
+    Route (POST) : Créer une nouvelle Issue.
+    """
+    user_id = str(client_user['user_id']) # ID du propriétaire du dépôt
+    data = request.get_json()
+    
+    repo_slug = data.get("repo_slug")
+    title = data.get("title")
+    description = data.get("description", "")
+    creator_id = str(client_user.get('uuid')) # ID de l'utilisateur connecté (créateur)
+    assigned_to = data.get("assigned_to")
+    labels = data.get("labels")
+
+    if not all([repo_slug, title]):
+        return jsonify({
+            "success": False, 
+            "message": "Données manquantes : repo_slug et title sont requis."
+        }), 400
+
+    issue_id, message = create_issue(
+        repo_slug=repo_slug,
+        user_id=user_id,
+        title=title,
+        description=description,
+        creator_id=creator_id,
+        assigned_to=assigned_to,
+        labels=labels
+    )
+
+    if issue_id:
+        return jsonify({
+            "success": True, 
+            "message": message, 
+            "issue_id": issue_id
+        }), 201
+    else:
+        return jsonify({
+            "success": False, 
+            "message": message
+        }), 500
+
+
+@issue_bp.route("/api/issue/list/<repo_slug>", methods=["GET"])
+@api_session_required
+def list_issues_route(client_user: Dict, repo_slug: str):
+    """
+    Route (GET) : Lister toutes les Issues pour un dépôt donné.
+    """
+    user_id = str(client_user['user_id'])
+    issue_list: List[Dict] = load_all_issues_from_hf(repo_slug, user_id)
+    
+    status_filter = request.args.get('status', 'all').lower()
+    if status_filter != 'all':
+        issue_list = [issue for issue in issue_list if issue.get('status', '').lower() == status_filter]
+    
+    return jsonify({
+        "success": True, 
+        "data": issue_list, 
+        "count": len(issue_list)
+    }), 200
+
+
+@issue_bp.route("/api/issue/detail/<repo_slug>/<issue_id>", methods=["GET"])
+@api_session_required
+def get_issue_details_route(client_user: Dict, repo_slug: str, issue_id: str):
+    """
+    Route (GET) : Récupérer les détails d'une Issue spécifique par son ID.
+    """
+    user_id = str(client_user['user_id'])
+    issue = get_issue_by_id(issue_id, repo_slug, user_id)
+    
+    if issue:
+        return jsonify({"success": True, "data": issue}), 200
+    else:
+        return jsonify({"success": False, "message": f"Issue ID {issue_id} non trouvée dans le dépôt {repo_slug}."}), 404
+
+
+@issue_bp.route("/api/issue/update/<repo_slug>/<issue_id>", methods=["PUT"])
+@api_session_required
+def update_issue_route(client_user: Dict, repo_slug: str, issue_id: str):
+    """
+    Route (PUT) : Mettre à jour des champs spécifiques (statut, titre, assignation, etc.) d'une Issue.
+    """
+    user_id = str(client_user['user_id'])
+    updates = request.get_json()
+    
+    if not updates:
+        return jsonify({"success": False, "message": "Aucune donnée de mise à jour fournie."}), 400
+
+    success, message = update_issue(issue_id, repo_slug, user_id, updates)
+
+    if success:
+        return jsonify({"success": True, "message": message}), 200
+    else:
+        return jsonify({"success": False, "message": message}), 404
+
+
+@issue_bp.route("/api/issue/comment/<repo_slug>/<issue_id>", methods=["POST"])
+@api_session_required
+def add_comment_route(client_user: Dict, repo_slug: str, issue_id: str):
+    """
+    Route (POST) : Ajouter un commentaire à une Issue.
+    """
+    user_id = str(client_user['user_id']) # ID du propriétaire du dépôt (pour l'accès au fichier)
+    commenter_id = str(client_user.get('uuid')) # ID de l'utilisateur connecté (commentateur)
+    data = request.get_json()
+    comment_content = data.get("content")
+
+    if not comment_content:
+        return jsonify({"success": False, "message": "Le contenu du commentaire est requis."}), 400
+
+    success, message = add_comment_to_issue(
+        issue_id=issue_id, 
+        repo_slug=repo_slug, 
+        user_id=user_id, 
+        comment_content=comment_content, 
+        commenter_id=commenter_id
+    )
+
+    if success:
+        return jsonify({"success": True, "message": message}), 201
+    else:
+        return jsonify({"success": False, "message": message}), 404
+
+
+@issue_bp.route("/api/issue/list_active_for_user", methods=["GET"])
+@api_session_required
+def list_active_issues_for_user_route(client_user: Dict):
+    """
+    Route (GET) : Récupérer tous les Issues actifs pour l'utilisateur
+    à travers tous ses dépôts (pour le dashboard).
+    """
+    user_id = str(client_user['user_id'])
+
+    try:
+        # 1. Charger TOUTES les Issues de l'utilisateur (de tous les dépôts)
+        all_issues_list = load_all_user_issues(user_id)
+
+        # 2. Filtrer seulement les Issues ouvertes (Open) pour le tableau de bord
+        active_issues = [issue for issue in all_issues_list if issue.get('status') == 'Open']
+
+    except Exception as e:
+        logger.error(f"Erreur lors du chargement des Issues du dashboard pour l'utilisateur {user_id} : {e}")
+        return jsonify({"success": False, "message": "Erreur interne lors du chargement des Issues."}), 500
+
+
+    # 3. Retourne la liste consolidée des Issues actives au format JSON
+    return jsonify({
+        "success": True,
+        "pull_requests": active_issues # Note: Le nom de la clé a été laissé 'pull_requests' pour la cohérence avec pr_routes.py
+    }), 200
+
+@issue_bp.route("/api/issue/list_by_repo", methods=["GET"])
+@api_session_required
+def list_issues_by_repo_route(client_user: Dict):
+
+    user_id = str(client_user['user_id'])
+    
+    # 1. Récupérer le repo_slug depuis les arguments de la requête (query string)
+    repo_slug = request.args.get('repo_slug')
+
+    if not repo_slug:
+        return jsonify({
+            "success": False, 
+            "message": "Le paramètre 'repo_slug' est manquant."
+        }), 400
+
+    try:
+        # 2. Charger toutes les Issues pour ce dépôt et cet utilisateur
+        all_issues = load_all_issues_from_hf(repo_slug, user_id)
+
+        # 3. Retourner la liste complète des Issues au format JSON
+        return jsonify({
+            "success": True, 
+            "issues": all_issues
+        }), 200
+
+    except Exception as e:
+        logger.error(f"Erreur lors du chargement des Issues pour le dépôt {repo_slug} et l'utilisateur {user_id} : {e}")
+        return jsonify({
+            "success": False, 
+            "message": "Erreur interne du serveur lors de la récupération des Issues."
+        }), 500

a6ea61c8-951a-413a-ba9d-7365d83fbd4d/mayproject/issues_backend.py

@@ -0,0 +1,196 @@
+# issues_backend.py
+
+import uuid
+from datetime import datetime
+from typing import Optional, Dict, List, Any
+import logging
+from config import ISSUES_HF_REPO_ID # Nouvelle variable
+from huggingface_repo_manager import (
+    load_json_file_from_hf, 
+    save_json_file_to_hf,
+    get_user_repo_metadata
+)
+
+logger = logging.getLogger(__name__)
+
+# --- Constantes ---
+ISSUE_FILE_PATH_TEMPLATE = "issues_data/{user_id}/{repo_slug}/issues.json"
+
+# --- Fonctions de Métadonnées (Interaction avec issues.json) ---
+
+def _get_issue_file_path(repo_slug: str, user_id: str) -> str:
+    """Construit le chemin d'accès au fichier issues.json."""
+    return ISSUE_FILE_PATH_TEMPLATE.format(user_id=user_id, repo_slug=repo_slug)
+
+def save_all_issues_to_hf(repo_slug: str, user_id: str, issues_list: List[Dict]) -> tuple[bool, str]:
+    """Sérialise et enregistre la liste complète des Issues dans le fichier issues.json."""
+    if not ISSUES_HF_REPO_ID:
+        return False, "Erreur de configuration: ISSUES_HF_REPO_ID manquant."
+
+    file_path = _get_issue_file_path(repo_slug, user_id)
+    data_to_save = {"issues": issues_list, "last_updated": datetime.now().isoformat()}
+
+    return save_json_file_to_hf(
+        file_path=file_path,
+        data=data_to_save,
+        commit_message=f"Mise à jour des issues pour {repo_slug}",
+        repo_id=ISSUES_HF_REPO_ID
+    )
+
+def load_all_issues_from_hf(repo_slug: str, user_id: str) -> List[Dict]:
+    """Charge l'intégralité du fichier issues.json du dépôt spécifié."""
+    if not ISSUES_HF_REPO_ID:
+        logger.error("Configuration error: ISSUES_HF_REPO_ID missing.")
+        return []
+
+    file_path = _get_issue_file_path(repo_slug, user_id)
+    
+    issue_data, msg = load_json_file_from_hf(
+        file_path=file_path, 
+        repo_id=ISSUES_HF_REPO_ID
+    )
+    
+    if issue_data is None or "issues" not in issue_data:
+        return []
+        
+    return issue_data.get("issues", [])
+
+def get_issue_by_id(issue_id: str, repo_slug: str, user_id: str) -> Optional[Dict]:
+    """Récupère une Issue spécifique par son ID."""
+    all_issues = load_all_issues_from_hf(repo_slug, user_id)
+    found_issue = next((i for i in all_issues if str(i.get('issue_id')) == str(issue_id)), None)
+    return found_issue
+
+def create_issue(
+    repo_slug: str, 
+    user_id: str, 
+    title: str, 
+    description: str, 
+    creator_id: str, 
+    assigned_to: Optional[str] = None,
+    labels: Optional[List[str]] = None
+) -> tuple[Optional[str], str]:
+    """Génère un issue_id, ajoute la nouvelle Issue, puis sauvegarde."""
+    
+    all_issues = load_all_issues_from_hf(repo_slug, user_id)
+    issue_id = str(uuid.uuid4())
+    
+    new_issue = {
+        "issue_id": issue_id,
+        "repo_slug": repo_slug,
+        "title": title,
+        "description": description,
+        "status": "Open", 
+        "creator_id": creator_id,
+        "assigned_to": assigned_to,
+        "labels": labels if labels is not None else [],
+        "created_at": datetime.now().isoformat(),
+        "updated_at": datetime.now().isoformat(),
+        "comments": []
+    }
+
+    all_issues.append(new_issue)
+    success, message = save_all_issues_to_hf(repo_slug, user_id, all_issues)
+    
+    if success:
+        return issue_id, f"Issue '{title}' créée avec succès (ID: {issue_id})."
+    else:
+        logger.error(f"Échec de la sauvegarde de l'issue {issue_id}: {message}")
+        return None, f"Échec de la création de l'Issue: {message}"
+
+
+def update_issue(issue_id: str, repo_slug: str, user_id: str, updates: Dict[str, Any]) -> tuple[bool, str]:
+    """Met à jour un ou plusieurs champs spécifiques (titre, statut, assignation, etc.)."""
+    all_issues = load_all_issues_from_hf(repo_slug, user_id)
+    issue_index = next((i for i, issue in enumerate(all_issues) if str(issue.get('issue_id')) == str(issue_id)), -1)
+    
+    if issue_index == -1:
+        return False, f"Issue ID {issue_id} introuvable."
+        
+    issue_to_update = all_issues[issue_index]
+    
+    for key, value in updates.items():
+        if key in issue_to_update:
+            issue_to_update[key] = value
+
+    issue_to_update['updated_at'] = datetime.now().isoformat()
+    all_issues[issue_index] = issue_to_update
+    
+    success, message = save_all_issues_to_hf(repo_slug, user_id, all_issues)
+    
+    if success:
+        return True, f"Issue ID {issue_id} mise à jour avec succès."
+    else:
+        logger.error(f"Échec de la sauvegarde de l'issue {issue_id} après mise à jour: {message}")
+        return False, f"Échec de la mise à jour de l'Issue: {message}"
+
+
+def add_comment_to_issue(
+    issue_id: str, 
+    repo_slug: str, 
+    user_id: str, 
+    comment_content: str, 
+    commenter_id: str
+) -> tuple[bool, str]:
+    """Ajoute un nouveau commentaire à la liste 'comments' de l'Issue correspondante et sauvegarde."""
+    all_issues = load_all_issues_from_hf(repo_slug, user_id)
+    issue_index = next((i for i, issue in enumerate(all_issues) if str(issue.get('issue_id')) == str(issue_id)), -1)
+    
+    if issue_index == -1:
+        return False, f"Issue ID {issue_id} introuvable."
+
+    issue_to_update = all_issues[issue_index]
+    
+    new_comment = {
+        "comment_id": str(uuid.uuid4()),
+        "user_id": commenter_id,
+        "content": comment_content,
+        "created_at": datetime.now().isoformat()
+    }
+    
+    if 'comments' not in issue_to_update:
+        issue_to_update['comments'] = []
+        
+    issue_to_update['comments'].append(new_comment)
+    issue_to_update['updated_at'] = datetime.now().isoformat()
+    all_issues[issue_index] = issue_to_update
+    
+    success, message = save_all_issues_to_hf(repo_slug, user_id, all_issues)
+    
+    if success:
+        return True, f"Commentaire ajouté avec succès à l'Issue ID {issue_id}."
+    else:
+        logger.error(f"Échec de la sauvegarde du commentaire pour l'issue {issue_id}: {message}")
+        return False, f"Échec de l'ajout du commentaire: {message}"
+
+
+def load_all_user_issues(user_id: str) -> List[Dict]:
+    """
+    Récupère toutes les Issues de l'utilisateur à travers tous ses dépôts
+    en utilisant les métadonnées de dépôt.
+    """
+    all_issues: List[Dict] = []
+    
+    try:
+        metadata, _ = get_user_repo_metadata(user_id)
+        if not metadata or not metadata.get("repos"):
+            return []
+
+        repo_slugs = [repo.get('repo_slug') for repo in metadata["repos"] if repo.get('repo_slug')]
+    except Exception as e:
+        logger.error(f"Erreur lors de la récupération des métadonnées de dépôt pour l'utilisateur {user_id}: {e}")
+        return []
+
+    for repo_slug in repo_slugs:
+        try:
+            issues_for_repo = load_all_issues_from_hf(repo_slug, user_id)
+            for issue in issues_for_repo:
+                issue['repo_slug'] = repo_slug
+            
+            all_issues.extend(issues_for_repo)
+            
+        except Exception as e:
+            logger.warning(f"Impossible de charger les Issues pour le dépôt {repo_slug}: {e}")
+            continue
+
+    return all_issues

a6ea61c8-951a-413a-ba9d-7365d83fbd4d/mayproject/pr_routes.py

@@ -0,0 +1,432 @@
+# pr_routes.py
+
+from flask import Blueprint, request, jsonify, session
+from decorators import api_session_required # Pour l'authentification par session
+from typing import List, Dict
+import logging
+
+# Importation des fonctions du backend Pull Request
+from pull_request_backend import (
+    create_pull_request,
+    load_all_prs_from_hf,
+    get_pull_request_by_id,
+    update_pull_request_status,
+    get_pr_diff,
+    check_pr_merge_status,
+    merge_pull_request,
+    load_all_user_prs,
+    create_new_pr_branch,
+    get_files_in_pr_branch,
+    get_pr_file_content,
+    get_repo_branches
+)
+
+logger = logging.getLogger(__name__)
+
+# Création du Blueprint 'pr_bp'
+pr_bp = Blueprint('pr_bp', __name__)
+
+# ----------------------------------------------------------------------
+# ENDPOINTS API POUR LES PULL REQUESTS
+# ----------------------------------------------------------------------
+
+@pr_bp.route("/api/pr/create", methods=["POST"])
+@api_session_required
+def create_pr_route(client_user: Dict):
+    """
+    Route (POST) : Créer une nouvelle Pull Request.
+    """
+    user_id = str(client_user['user_id'])
+    data = request.get_json()
+    
+    repo_slug = data.get("repo_slug")
+    source_branch = data.get("source_branch")
+    target_branch = data.get("target_branch")
+    title = data.get("title")
+    description = data.get("description", "") # Description optionnelle
+
+    if not all([repo_slug, source_branch, target_branch, title]):
+        return jsonify({
+            "success": False, 
+            "message": "Données manquantes : repo_slug, source_branch, target_branch et title sont requis."
+        }), 400
+
+    pr_id, message = create_pull_request(
+        repo_slug=repo_slug,
+        source_branch=source_branch,
+        target_branch=target_branch,
+        title=title,
+        description=description,
+        user_id=user_id
+    )
+
+    if pr_id:
+        return jsonify({
+            "success": True, 
+            "message": message, 
+            "pr_id": pr_id
+        }), 201
+    else:
+        return jsonify({
+            "success": False, 
+            "message": message
+        }), 500
+
+
+@pr_bp.route("/api/pr/list/<repo_slug>", methods=["GET"])
+@api_session_required
+def list_prs_route(client_user: Dict, repo_slug: str):
+    """
+    Route (GET) : Lister toutes les PR pour un dépôt donné.
+    """
+    user_id = str(client_user['user_id'])
+    
+    pr_list: List[Dict] = load_all_prs_from_hf(repo_slug, user_id)
+    
+    # Optionnel: Filtrer ou trier ici si nécessaire (ex: trier par date/statut)
+    
+    return jsonify({
+        "success": True, 
+        "data": pr_list, 
+        "count": len(pr_list)
+    }), 200
+
+
+@pr_bp.route("/api/pr/<pr_id>", methods=["GET"])
+@api_session_required
+def get_pr_details_route(client_user: Dict, pr_id: str):
+    """
+    Route (GET) : Obtenir les détails d'une PR spécifique.
+    """
+    user_id = str(client_user['user_id'])
+    repo_slug = request.args.get('repo')
+    
+    if not repo_slug:
+        return jsonify({
+            "success": False, 
+            "message": "Le paramètre 'repo' (repo_slug) est manquant dans la requête."
+        }), 400
+
+    pr = get_pull_request_by_id(pr_id, repo_slug, user_id)
+    
+    if pr:
+        return jsonify({"success": True, "data": pr}), 200
+    else:
+        return jsonify({"success": False, "message": f"Pull Request ID {pr_id} non trouvée."}), 404
+
+
+@pr_bp.route("/api/pr/<pr_id>/diff", methods=["GET"])
+@api_session_required
+def get_pr_diff_route(client_user: Dict, pr_id: str):
+    """
+    Route (GET) : Obtenir le contenu des changements (diff) entre les branches de la PR.
+    """
+    user_id = str(client_user['user_id'])
+    repo_slug = request.args.get('repo')
+    
+    if not repo_slug:
+        return jsonify({
+            "success": False, 
+            "message": "Le paramètre 'repo' (repo_slug) est manquant."
+        }), 400
+
+    # La fonction de backend résout les branches à partir du pr_id
+    diff_data, message = get_pr_diff(repo_slug, user_id, pr_id)
+
+    if diff_data is not None:
+        return jsonify({"success": True, "data": diff_data}), 200
+    else:
+        # Ceci peut être dû à un pr_id invalide ou à une erreur de diff
+        return jsonify({"success": False, "message": message}), 404
+        
+        
+@pr_bp.route("/api/pr/<pr_id>/merge", methods=["POST"])
+@api_session_required
+def merge_pr_route(client_user: Dict, pr_id: str):
+    """
+    Route (POST) : Exécuter la fusion (merge) de la PR.
+    """
+    user_id = str(client_user['user_id'])
+    data = request.get_json()
+    repo_slug = data.get("repo_slug")
+
+    if not repo_slug:
+        return jsonify({"success": False, "message": "Le 'repo_slug' est requis dans le corps de la requête."}), 400
+
+    # Le committer est l'utilisateur connecté
+    success, message = merge_pull_request(pr_id, repo_slug, user_id, committer_id=user_id)
+
+    if success:
+        return jsonify({"success": True, "message": f"Pull Request ID {pr_id} fusionnée avec succès."}), 200
+    else:
+        # Erreur lors de la vérification des conflits, de la fusion Git ou de la mise à jour du statut
+        return jsonify({"success": False, "message": message}), 409 # 409 Conflict ou 500
+
+@pr_bp.route("/api/pr/<pr_id>/close", methods=["POST"])
+@api_session_required
+def close_pr_route(client_user: Dict, pr_id: str):
+    """
+    Route (POST) : Fermer (sans fusion) la PR.
+    """
+    user_id = str(client_user['user_id'])
+    data = request.get_json()
+    repo_slug = data.get("repo_slug")
+
+    if not repo_slug:
+        return jsonify({"success": False, "message": "Le 'repo_slug' est requis dans le corps de la requête."}), 400
+
+    success, message = update_pull_request_status(pr_id, repo_slug, user_id, "Closed")
+
+    if success:
+        return jsonify({"success": True, "message": f"Pull Request ID {pr_id} fermée."}), 200
+    else:
+        return jsonify({"success": False, "message": message}), 404
+
+@pr_bp.route("/api/pr/list_all", methods=["GET"])
+@api_session_required
+def list_all_prs_route(client_user: Dict):
+    """
+    Route (GET) : Récupérer tous les Pull Requests pour un dépôt donné.
+    Nécessite 'repo_slug' en paramètre de requête (query parameter).
+    """
+    user_id = str(client_user['user_id'])
+    # Récupère le repo_slug depuis les paramètres de la requête GET
+    repo_slug = request.args.get("repo_slug")
+
+    if not repo_slug:
+        return jsonify({"success": False, "message": "Le 'repo_slug' est requis comme paramètre de requête."}), 400
+    
+    # 1. Appel de la fonction backend pour charger les PRs
+    # (Doit être déjà importée : from pull_request_backend import load_all_prs_from_hf)
+    try:
+        prs_list = load_all_prs_from_hf(repo_slug, user_id)
+    except Exception as e:
+        logger.error(f"Erreur lors du chargement des PRs pour {repo_slug} : {e}")
+        return jsonify({"success": False, "message": "Erreur interne lors du chargement des Pull Requests."}), 500
+
+
+    # 2. Retourne la liste des PRs au format JSON pour le frontend
+    return jsonify({
+        "success": True,
+        "repo_slug": repo_slug,
+        "pull_requests": prs_list
+    }), 200
+
+@pr_bp.route("/api/pr/<pr_id>", methods=["GET"])
+@api_session_required
+def get_single_pr_route(client_user: Dict, pr_id: str):
+    """
+    Route (GET) : Récupérer les détails d'un seul Pull Request par son ID.
+    Nécessite 'repo_slug' en paramètre de requête.
+    """
+    user_id = str(client_user['user_id'])
+    # Récupère le repo_slug depuis les paramètres de la requête GET
+    repo_slug = request.args.get("repo_slug")
+
+    if not repo_slug:
+        return jsonify({"success": False, "message": "Le 'repo_slug' est requis comme paramètre de requête."}), 400
+
+    # 1. Récupérer les métadonnées de la PR
+    pr_data = get_pull_request_by_id(pr_id, repo_slug, user_id)
+    
+    if not pr_data:
+        return jsonify({"success": False, "message": f"Pull Request ID {pr_id} introuvable."}), 404
+
+    # 2. Récupérer le contenu du Diff pour l'affichage des changements
+    diff_content, diff_msg = get_pr_diff(pr_id, repo_slug, user_id)
+    
+    # 3. Ajouter le diff à l'objet retourné (même s'il est vide/erreur)
+    pr_data['diff_content'] = diff_content
+    # pr_data['diff_message'] = diff_msg # Utile pour le debug
+
+    return jsonify({
+        "success": True,
+        "pull_request": pr_data
+    }), 200
+
+@pr_bp.route("/api/pr/list_active_for_user", methods=["GET"])
+@api_session_required
+def list_active_prs_for_user_route(client_user: Dict):
+    """
+    Route (GET) : Récupérer tous les Pull Requests actifs pour l'utilisateur
+    à travers tous ses dépôts.
+    """
+    user_id = str(client_user['user_id'])
+
+    try:
+        # 1. Charger TOUTES les PRs de l'utilisateur (de tous les dépôts)
+        all_prs_list = load_all_user_prs(user_id)
+
+        # 2. Filtrer seulement les PRs ouvertes (Open) pour le tableau de bord
+        # (Si l'on veut seulement les PRs actives)
+        active_prs = [pr for pr in all_prs_list if pr.get('status') == 'Open']
+
+    except Exception as e:
+        logger.error(f"Erreur lors du chargement des PRs du dashboard pour l'utilisateur {user_id} : {e}")
+        return jsonify({"success": False, "message": "Erreur interne lors du chargement des Pull Requests."}), 500
+
+
+    # 3. Retourne la liste consolidée des PRs actives au format JSON
+    return jsonify({
+        "success": True,
+        "pull_requests": active_prs
+    }), 200
+
+
+@pr_bp.route("/api/pr/create_branch", methods=["POST"])
+@api_session_required
+def create_pr_branch_route(client_user: Dict):
+    """
+    Route (POST) : Créer une nouvelle branche de développement isolée 
+    pour une future Pull Request.
+    
+    Requiert: repo_slug et branch_name (qui sera la source_branch).
+    """
+    user_id = str(client_user['user_id'])
+    data = request.get_json()
+    
+    repo_slug = data.get("repo_slug")
+    new_branch_name = data.get("branch_name") # Nom de la nouvelle branche à créer (ex: 'feature-new-ui')
+
+    if not all([repo_slug, new_branch_name]):
+        return jsonify({
+            "success": False, 
+            "message": "Données manquantes : repo_slug et branch_name sont requis."
+        }), 400
+
+    # Appel de la fonction backend qui copie les fichiers
+    success, message = create_new_pr_branch(
+        user_id=user_id,
+        repo_slug=repo_slug,
+        new_branch_name=new_branch_name
+    )
+
+    if success:
+        return jsonify({
+            "success": True, 
+            "message": message,
+            "branch_name": new_branch_name
+        }), 201
+    else:
+        return jsonify({
+            "success": False, 
+            "message": message
+        }), 500 # 500 Internal Server Error ou 409 Conflict si la branche existe déjà.
+
+@pr_bp.route("/api/pr/<pr_id>/files", methods=["GET"])
+@api_session_required
+def get_pr_files_route(client_user: Dict, pr_id: str):
+    """
+    Route (GET) : Obtenir la liste de tous les chemins de fichiers dans la 
+    branche source (source_branch) d'une Pull Request spécifique.
+    
+    Nécessite 'repo_slug' en paramètre de requête.
+    """
+    user_id = str(client_user['user_id'])
+    # Récupère le repo_slug depuis les paramètres de la requête GET (Query Parameter)
+    repo_slug = request.args.get('repo')
+    
+    if not repo_slug:
+        return jsonify({
+            "success": False, 
+            "message": "Le paramètre 'repo' (repo_slug) est manquant dans la requête."
+        }), 400
+
+    # 1. Appel de la fonction backend que nous venons de créer
+    file_list, message = get_files_in_pr_branch(pr_id, repo_slug, user_id)
+
+    if not file_list and message:
+        # La fonction retourne un message d'erreur si la PR ou la branche n'est pas trouvée
+        # ou s'il y a une erreur d'API.
+        return jsonify({
+            "success": False, 
+            "message": message
+        }), 404 # Ou 500 pour une erreur interne
+
+    # 2. Retourne la liste des fichiers (chemin relatif)
+    return jsonify({
+        "success": True, 
+        "pr_id": pr_id,
+        "repo_slug": repo_slug,
+        "files": file_list,
+        "count": len(file_list)
+    }), 200
+
+@pr_bp.route("/api/pr/<pr_id>/file", methods=["GET"])
+@api_session_required
+def get_pr_file_content_route(client_user: Dict, pr_id: str):
+    """
+    Route (GET) : Obtenir le contenu d'un fichier spécifique dans la branche source de la PR.
+    
+    Nécessite 'repo' (repo_slug) et 'path' (file_path) en paramètres de requête.
+    """
+    user_id = str(client_user['user_id'])
+    
+    repo_slug = request.args.get('repo')
+    file_path = request.args.get('path')
+    
+    if not all([repo_slug, file_path]):
+        return jsonify({
+            "success": False, 
+            "message": "Les paramètres 'repo' (repo_slug) et 'path' (file_path) sont requis."
+        }), 400
+
+    # 1. Appel de la fonction backend
+    content, message = get_pr_file_content(
+        pr_id=pr_id, 
+        repo_slug=repo_slug, 
+        user_id=user_id, 
+        file_path=file_path
+    )
+
+    if content is not None:
+        return jsonify({
+            "success": True, 
+            "file_path": file_path,
+            "content": content
+        }), 200
+    else:
+        return jsonify({
+            "success": False, 
+            "message": message
+        }), 404
+
+@pr_bp.route("/api/repo/<repo_slug>/branches", methods=["GET"])
+@api_session_required
+def get_repo_branches_route(client_user: Dict, repo_slug: str):
+    """
+    Route (GET) : Récupère la liste de toutes les branches disponibles
+    pour un dépôt utilisateur spécifique (y compris la branche principale et les branches de PR ouvertes).
+    """
+    user_id = str(client_user['user_id'])
+    
+    if not repo_slug:
+        return jsonify({
+            "success": False, 
+            "message": "Le 'repo_slug' est requis dans le chemin de l'URL."
+        }), 400
+
+    # 1. Appel de la fonction backend
+    # Assurez-vous que get_repo_branches est bien importé de pull_request_backend
+    try:
+        branches, message = get_repo_branches(repo_slug, user_id)
+    except Exception as e:
+        logger.error(f"Erreur lors de la récupération des branches pour {repo_slug}: {e}")
+        return jsonify({
+            "success": False, 
+            "message": f"Erreur interne lors de la récupération des branches : {str(e)}"
+        }), 500
+
+    if message and not branches:
+        # Gérer les cas où il y a un message d'erreur et aucune branche n'a pu être récupérée
+         return jsonify({
+            "success": False, 
+            "message": message
+        }), 404
+        
+    return jsonify({
+        "success": True, 
+        "repo_slug": repo_slug,
+        "branches": branches,
+        "count": len(branches)
+    }), 200

a6ea61c8-951a-413a-ba9d-7365d83fbd4d/mayproject/project_routes.py

@@ -0,0 +1,1123 @@
+# project_routes.py (Version SSR - Rendu Côté Serveur)
+
+from datetime import datetime # <-- AJOUTER CECI
+import logging # <-- NOUVEL IMPORT
+import os  # <--- AJOUTEZ CETTE LIGNE
+from flask import Blueprint, request, jsonify, session, redirect, url_for, flash, render_template
+import uuid
+import json # <-- AJOUTER CECI, nécessaire pour décoder le JSON du formulaire
+from decorators import login_required
+from auth_backend import (
+    register_user,
+    login_user,
+    reset_password_via_security_question,
+    get_user_by_id,
+    update_user_profile,
+    # Assurez-vous d'importer toute autre fonction nécessaire ici (ex: is_email_unique)
+)
+
+from decorators import api_session_required 
+from huggingface_repo_manager import (
+    create_empty_repo_folder_on_hf,
+    update_user_repo_metadata,
+    get_user_repo_metadata, 
+    upload_files_to_repo_backend, 
+    delete_repo_folder_from_hf, # <--- AJOUTEZ CETTE LIGNE
+    list_repo_files_from_hf, # <-- DÉJÀ EXISTANT DANS LE FICHIER FOURNI
+    get_file_content_from_hf, # <-- NOUVELLE FONCTION AJOUTÉE
+    save_file_content_to_hf,
+    delete_file_from_hf_repo,
+    save_application_json_to_hf, # <--- AJOUTÉ
+    upload_application_document_to_hf, # <--- AJOUTÉ
+    update_repo_secrets_or_variables, # <--- AJOUTER CETTE LIGNE
+    get_repo_secrets_or_variables,
+    delete_repo_secret_or_variable, # <--- NOUVELLE FONCTION DE SUPPRESSION
+)
+logger = logging.getLogger(__name__) # <-- AJOUTER CETTE LIGNE
+
+
+project_bp = Blueprint('project_bp', __name__)
+
+@project_bp.route("/mindus/nexus/upload_file", methods=["GET"])
+@login_required
+def upload_file_page():
+    """
+    Route dédiée pour la page d'upload de fichiers.
+    Charge les données utilisateur et les métadonnées du dépôt pour l'affichage Jinja2.
+    """
+    user_id = session.get('user_id')
+    repo_slug = request.args.get('repo_slug')
+    
+    # 1. Charger les données utilisateur complètes
+    user_data = get_user_by_id(user_id) # get_user_by_id est déjà importé
+    if user_data is None:
+        session.pop('user_id', None)
+        session.pop('logged_in', None)
+        return redirect(url_for('web_bp.connexion_page'))
+        
+    # 2. Charger les métadonnées pour trouver le nom du dépôt
+    repo_name = None
+    if repo_slug:
+        # get_user_repo_metadata est déjà importé
+        metadata, _ = get_user_repo_metadata(user_id) 
+        if metadata and metadata.get("repos"):
+            # Trouver le nom du dépôt correspondant au slug
+            repo = next((r for r in metadata["repos"] if r.get('repo_slug') == repo_slug), None)
+            if repo:
+                repo_name = repo.get('repo_name')
+
+    # CORRECTION de l'affichage: Assurer qu'il y a une valeur non-None pour le template
+    # Même si le repo_name n'est pas trouvé dans les métadonnées, on passe le repo_slug
+    # qui sera affiché par le template si repo_name est None.
+    
+    # 3. Passer l'objet 'user', le nom (repo_name) et le slug du dépôt au template
+    return render_template(
+        "upload_file.html", 
+        user=user_data, 
+        repo_name=repo_name, 
+        repo_slug=repo_slug # Nécessaire pour les liens et actions JavaScript
+    )
+
+
+
+@project_bp.route("/mindus/nexus/nouveau_project", methods=["GET"])
+@login_required
+def nouveau_project_page_with_user_context():
+    """
+    Route dédiée pour la page de création de projet (nouveau_project.html).
+    Injecte l'objet 'user' dans le contexte du template pour résoudre l'erreur Jinja2.
+    """
+    user_id = session.get('user_id')
+    
+    # 1. Charger les données utilisateur complètes depuis le backend
+    # get_user_by_id est déjà importé en haut du fichier.
+    user_data = get_user_by_id(user_id) 
+
+    if user_data is None:
+        # Sécurité : Si les données ne sont pas trouvées, on déconnecte et redirige
+        session.pop('user_id', None)
+        session.pop('logged_in', None)
+        return redirect(url_for('user_bp.login_user_api'))
+        
+    # 2. Passer l'objet 'user' au template (Ceci corrige l'erreur)
+    return render_template("nouveau_project.html", user=user_data)
+
+
+@project_bp.route("/mindus/nexus/repo_files", methods=["GET"])
+@login_required
+def get_repo_files_page():
+    user_id = session.get('user_id')
+    
+    # Étape 1: Assurez-vous de récupérer le repo_slug de l'URL (qui devrait être présent)
+    repo_slug = request.args.get('repo_slug')
+    
+    if not repo_slug:
+        # Gérer le cas où le slug est manquant (ex: redirection vers le dashboard)
+        flash("Dépôt non spécifié.", "error")
+        return redirect(url_for('user_bp.dashboard')) 
+
+    
+    # Étape 2: Assurez-vous de passer repo_slug au template
+    return render_template(
+        'repo_files.html', 
+        user=get_user_by_id(user_id), 
+        repo_slug=repo_slug, 
+        # ... autres variables (file_list, repo_name, etc.)
+    )
+
+@project_bp.route("/mindus/nexus/pull_requests", methods=["GET"])
+@login_required
+def get_pull_requests_page():
+    """
+    Route dédiée pour la page de gestion des Pull Requests (pull_requests.html).
+    Récupère repo_slug de l'URL et injecte l'objet 'user' dans le contexte.
+    """
+    user_id = session.get('user_id')
+    
+    # 1. Assurez-vous de récupérer le repo_slug de l'URL
+    repo_slug = request.args.get('repo_slug')
+    
+    # 2. Gestion si le slug est manquant
+    if not repo_slug:
+        flash("Dépôt non spécifié pour les Pull Requests.", "error")
+        return redirect(url_for('user_bp.dashboard')) 
+
+    # 3. Charger les données utilisateur (nécessaire pour le contexte Jinja2)
+    user_data = get_user_by_id(user_id)
+    
+    # 4. Rendu du template avec le contexte
+    return render_template(
+        'pull_requests.html', 
+        user=user_data, 
+        repo_slug=repo_slug # Passage du slug au template
+    )
+
+@project_bp.route("/mindus/nexus/new_pull_requests", methods=["GET"])
+@login_required
+def get_new_pull_requests_page():
+    """
+    Route dédiée pour la page de création d'une nouvelle Pull Request (new_pull_requests.html).
+    Récupère repo_slug de l'URL et injecte l'objet 'user' dans le contexte.
+    """
+    user_id = session.get('user_id')
+    
+    # 1. Assurez-vous de récupérer le repo_slug de l'URL
+    repo_slug = request.args.get('repo_slug')
+    
+    # 2. Gestion si le slug est manquant
+    if not repo_slug:
+        flash("Dépôt non spécifié pour la création de Pull Request.", "error")
+        return redirect(url_for('user_bp.dashboard')) 
+
+    # 3. Charger les données utilisateur (nécessaire pour le contexte Jinja2)
+    user_data = get_user_by_id(user_id)
+    
+    # 4. Rendu du template avec le contexte
+    return render_template(
+        'new_pull_requests.html', 
+        user=user_data, 
+        repo_slug=repo_slug # Passage du slug au template
+    )
+
+
+@project_bp.route("/mindus/nexus/issues", methods=["GET"])
+@login_required
+def get_issues_list_page():
+    """
+    Route (SSR) pour afficher la liste des Issues d'un dépôt (issues.html).
+    Nécessite 'repo_slug' en paramètre de requête.
+    """
+    user_id = session.get('user_id')
+    repo_slug = request.args.get('repo_slug')
+    
+    if not repo_slug:
+        flash("Dépôt non spécifié pour les Issues.", "error")
+        return redirect(url_for('user_bp.dashboard')) 
+
+    # Charger les données utilisateur (get_user_by_id est déjà importé)
+    user_data = get_user_by_id(user_id)
+    
+    return render_template(
+        'issues.html', 
+        user=user_data, 
+        repo_slug=repo_slug # Passage du slug au template
+    )
+
+
+@project_bp.route("/mindus/nexus/new_issue", methods=["GET"])
+@login_required
+def get_new_issue_page():
+    """
+    Route (SSR) pour afficher le formulaire de création de nouvelle Issue (new_issue.html).
+    Nécessite 'repo_slug' en paramètre de requête.
+    """
+    user_id = session.get('user_id')
+    repo_slug = request.args.get('repo_slug')
+    
+    if not repo_slug:
+        flash("Dépôt non spécifié pour la création d'Issue.", "error")
+        return redirect(url_for('user_bp.dashboard')) 
+
+    # Charger les données utilisateur (get_user_by_id est déjà importé)
+    user_data = get_user_by_id(user_id)
+    
+    return render_template(
+        'new_issue.html', 
+        user=user_data, 
+        repo_slug=repo_slug # Passage du slug au template
+    )
+
+@project_bp.route("/mindus/nexus/create_new_issue", methods=["GET"])
+@login_required
+def get_create_new_issue_page():
+    """
+    Route dédiée pour la page de création d'une nouvelle Pull Request (new_pull_requests.html).
+    Récupère repo_slug de l'URL et injecte l'objet 'user' dans le contexte.
+    """
+    user_id = session.get('user_id')
+    
+    # 1. Assurez-vous de récupérer le repo_slug de l'URL
+    repo_slug = request.args.get('repo_slug')
+    
+    # 2. Gestion si le slug est manquant
+    if not repo_slug:
+        flash("Dépôt non spécifié pour la création de Pull Request.", "error")
+        return redirect(url_for('user_bp.dashboard')) 
+
+    # 3. Charger les données utilisateur (nécessaire pour le contexte Jinja2)
+    user_data = get_user_by_id(user_id)
+    
+    # 4. Rendu du template avec le contexte
+    return render_template(
+        'create_new_issue.html', 
+        user=user_data, 
+        repo_slug=repo_slug # Passage du slug au template
+    )
+
+
+@project_bp.route("/mindus/nexus/media_image")
+@login_required
+def get_media_image():
+    user_id = session.get('user_id')
+    
+    # 1. Charger les données utilisateur
+    # Assurez-vous que get_user_by_id est bien importé (il l'est déjà dans ce fichier)
+    user_data = get_user_by_id(user_id) 
+
+    if user_data is None:
+        # Sécurité : Si les données ne sont pas trouvées, on déconnecte et redirige
+        session.pop('user_id', None)
+        session.pop('logged_in', None)
+        # Assurez-vous que la redirection vers la page de connexion est correcte
+        return redirect(url_for('web_bp.connexion_page'))
+    
+    # 2. Passer les données utilisateur au template
+    # Si le template attend 'current_user', utilisez ce nom.
+    # Dans le cas où d'autres routes utilisent 'user', vous pouvez aussi le passer sous ce nom.
+    return render_template(
+        'media_image.html',
+        current_user=user_data, # <-- AJOUT CLÉ
+        user=user_data           # (Optionnel) Ajout de 'user' par précaution
+    )
+
+@project_bp.route('/api/create_repo', methods=['POST'])
+@api_session_required
+def create_repo(client_user):
+    """ 
+    Gère la création d'un nouveau dépôt utilisateur:
+    1. Crée la structure de dossier (user_id/repo_slug/) sur Hugging Face (via README.md).
+    2. Met à jour le fichier de métadonnées utilisateur (user_id/metadata.json) sur HF.
+    """
+    # CORRECTION : Utiliser 'user_id' car c'est la clé définie dans baserow_storage.py
+    user_id = client_user.get('user_id')
+    
+    # Si 'user_id' est toujours None, c'est que l'utilisateur n'est pas correctement authentifié
+    # ou que l'objet client_user est incomplet.
+    if not user_id:
+        # Ceci est la réponse que vous voyez actuellement au frontend.
+        return jsonify({"success": False, "message": "Erreur d'authentification: ID utilisateur manquant."}), 401
+    
+    data = request.get_json()
+    repo_name = data.get('repo_name', '').strip()
+    visibility = data.get('visibility', 'public')
+    description = data.get('description', '')
+    gitignore_template = data.get('gitignore_template')
+    license_template = data.get('license_template')
+    
+    if not repo_name:
+        return jsonify({"success": False, "message": "Le nom du dépôt est obligatoire."}), 400
+
+    # 1. Générer un identifiant unique pour le déploiement/dépôt (UUID)
+    deploy_id = str(uuid.uuid4())
+    # Créer un slug pour le dossier (version simplifiée)
+    repo_slug = repo_name.lower().replace(' ', '-') 
+
+    try:
+        # 2. Créer la structure de dossier (dossier principal/sous-dossier du dépôt) sur Hugging Face
+        success_hf_creation, hf_message = create_empty_repo_folder_on_hf(
+            repo_slug=repo_slug,
+            user_id=user_id # Utilise l'ID utilisateur réel
+        )
+
+        if not success_hf_creation:
+            logger.error(f"Échec de la création du dossier HF pour {user_id}/{repo_slug}: {hf_message}")
+            return jsonify({"success": False, "message": f"Échec de la création du dépôt sur Hugging Face: {hf_message}"}), 500
+
+        # Le chemin complet du dépôt dans le dataset HF
+        hf_repo_path = f"{user_id}/{repo_slug}"
+
+        # 3. Préparer les métadonnées à enregistrer
+        new_repo_data = {
+            "FIELD_DEPLOY_ID": deploy_id, 
+            "FIELD_USER_REF": user_id, 
+            "FIELD_HF_REPO_PATH": hf_repo_path,
+            "repo_name": repo_name,
+            "repo_slug": repo_slug,
+            "description": description,
+            "visibility": visibility,
+            "gitignore_template": gitignore_template,
+            "license_template": license_template,
+            "created_at": datetime.now().isoformat(),
+            "status": "initialised"
+        }
+        
+        # 4. Mettre à jour le fichier metadata.json de l'utilisateur
+        success_metadata, metadata_message = update_user_repo_metadata(
+            user_id=user_id, 
+            new_repo_data=new_repo_data
+        ) 
+        
+        if not success_metadata:
+            logger.critical(f"Dépôt {deploy_id} créé sur HF, mais ÉCHEC CRITIQUE de mise à jour des métadonnées pour {user_id}: {metadata_message}")
+            return jsonify({"success": False, "message": f"Dépôt créé, mais ÉCHEC CRITIQUE de la mise à jour des métadonnées. Contactez le support."}), 500
+            
+        # 5. Succès
+        # Le succès enverra cette réponse, déclenchant la redirection du frontend vers repo_files.html
+        return jsonify({
+            "success": True, 
+            "message": f"Dépôt '{repo_name}' créé et enregistré avec succès.", 
+            "deploy_id": deploy_id,
+            "repo_slug": repo_slug, # Clé pour la redirection côté frontend
+        }), 201
+
+    except Exception as e:
+        logger.exception(f"Erreur inattendue lors de la création du dépôt pour {user_id}: {e}")
+        return jsonify({"success": False, "message": f"Erreur interne lors du traitement: {str(e)}"}), 500
+
+@project_bp.route('/api/repos', methods=['GET'])
+@api_session_required
+def get_user_repos(client_user):
+    """
+    Récupère la liste de tous les dépôts (repos) de l'utilisateur à partir de ses métadonnées HF.
+    """
+    user_id = client_user.get('user_id')
+    
+    if not user_id:
+        return jsonify({"success": False, "message": "Erreur d'authentification: ID utilisateur manquant."}), 401
+        
+    try:
+        # get_user_repo_metadata est importé de huggingface_storage
+        metadata, message = get_user_repo_metadata(user_id)
+        
+        if metadata and metadata.get("repos"):
+            # Retourne uniquement la liste des dépôts
+            # triée par date de création (du plus récent au plus ancien)
+            repos = metadata["repos"]
+            # Assurez-vous d'avoir 'created_at' pour le tri, sinon utilisez une autre clé
+            repos.sort(key=lambda x: x.get('created_at', ''), reverse=True) 
+            
+            # Ne retournez que les champs nécessaires pour le dashboard
+            simplified_repos = [
+                {
+                    "repo_name": repo.get("repo_name", "N/A"),
+                    "repo_slug": repo.get("repo_slug", "N/A"),
+                    "description": repo.get("description", "Pas de description fournie."),
+                    "visibility": repo.get("visibility", "public").capitalize(),
+                    "deploy_id": repo.get("FIELD_DEPLOY_ID", "N/A"),
+                    # Utilisez un champ d'exemple pour la date de modification/création
+                    "last_modified": repo.get("created_at", datetime.now().isoformat()),
+                } for repo in repos
+            ]
+            
+            return jsonify({"success": True, "repos": simplified_repos})
+        else:
+            # Aucun dépôt trouvé ou metadata non initialisé
+            return jsonify({"success": True, "repos": []})
+            
+    except Exception as e:
+        logger.exception(f"Erreur lors de la récupération des dépôts HF pour {user_id}: {e}")
+        return jsonify({"success": False, "message": f"Erreur interne lors de l'accès aux dépôts: {str(e)}"}), 500
+
+@project_bp.route('/api/files/<repo_slug>/upload', methods=['POST'])
+@api_session_required
+def upload_files_to_repo(client_user, repo_slug):
+    """
+    Gère le téléversement de plusieurs fichiers vers un dépôt utilisateur spécifique.
+    """
+    user_id = client_user.get('user_id')
+    
+    if not user_id:
+        return jsonify({"success": False, "message": "Erreur d'authentification: ID utilisateur manquant."}), 401
+    
+    # ... (le code pour la récupération des fichiers et du formulaire)
+    if 'files' not in request.files:
+        return jsonify({"success": False, "message": "Aucun fichier n'a été sélectionné pour le téléversement."}), 400
+        
+    commit_title = request.form.get('commit_title', "Add files via upload")
+    commit_description = request.form.get('commit_description', "")
+    branch_name = request.form.get('branch_name', 'main')
+    
+    uploaded_files = request.files.getlist('files')
+    
+    if not uploaded_files:
+        return jsonify({"success": False, "message": "Aucun fichier valide n'a été trouvé dans la requête."}), 400
+
+    # --- ÉTAPE CLÉ : Appel de la fonction du backend (DÉSORMAIS ACTIF) ---
+    success, message = upload_files_to_repo_backend(
+        user_id=user_id,
+        repo_slug=repo_slug,
+        files=uploaded_files,
+        commit_message=commit_title,
+        commit_description=commit_description,
+        branch=branch_name
+    )
+    
+    if success:
+        # --- MODIFICATION CLÉ ICI ---
+        # 1. Générer l'URL de redirection vers la page repo_files.html
+        redirect_url = url_for('project_bp.get_repo_files_page', repo_slug=repo_slug)
+        
+        # 2. Renvoyer le 'redirect' dans la réponse JSON pour que le frontend le suive
+        return jsonify({
+            "success": True, 
+            "message": message,
+            "redirect": redirect_url, # <-- AJOUT DE LA REDIRECTION
+        }), 200
+    else:
+        # Échec : Retourne l'erreur reçue du backend HF
+        return jsonify({"success": False, "message": message}), 500 # Statut 500 pour Erreur Serveur Interne
+
+        
+@project_bp.route('/api/repo_data/<repo_slug>', methods=['GET'])
+@api_session_required
+def get_repo_data(client_user, repo_slug):
+    """
+    Récupère la liste des fichiers, le contenu du README.md et les métadonnées 
+    du dépôt pour l'affichage de la page repo_files.html.
+    """
+    user_id = client_user.get('user_id')
+    
+    if not user_id:
+        return jsonify({"success": False, "message": "Erreur d'authentification: ID utilisateur manquant."}), 401
+    
+    response_data = {}
+    
+    # 1. Récupérer les métadonnées spécifiques du dépôt (Pour la carte 'About')
+    try:
+        user_metadata, _ = get_user_repo_metadata(user_id)
+        repo_metadata = next(
+            (repo for repo in user_metadata.get("repos", []) if repo.get("repo_slug") == repo_slug), 
+            None
+        )
+        
+        if not repo_metadata:
+            return jsonify({"success": False, "message": f"Dépôt '{repo_slug}' non trouvé dans les métadonnées de l'utilisateur."}), 404
+            
+        # Simplifier les métadonnées pour le frontend
+        repo_info = {
+            "repo_name": repo_metadata.get("repo_name", repo_slug),
+            "description": repo_metadata.get("description", f"{repo_slug} for developers"),
+            "visibility": repo_metadata.get("visibility", "Private"),
+            # Les données dynamiques (watching, stars, forks) sont à 0 pour l'instant
+            "license": repo_metadata.get("license_template", "No license"), 
+        }
+        response_data['repo_info'] = repo_info
+    except Exception as e:
+        logger.error(f"Erreur lors de la récupération des métadonnées du dépôt {user_id}/{repo_slug}: {e}")
+        # Continuer même en cas d'erreur de métadonnées pour charger au moins les fichiers
+        response_data['repo_info'] = {}
+
+    # 2. Récupérer la liste des fichiers du dépôt
+    file_list, file_message = list_repo_files_from_hf(repo_slug, user_id)
+    
+    if not file_list and "404" in file_message:
+         # Le dépôt existe dans les métadonnées mais est vide sur HF (pas de fichiers)
+         response_data['file_list'] = []
+    elif not file_list:
+        logger.error(f"Échec de la liste des fichiers pour {user_id}/{repo_slug}: {file_message}")
+        return jsonify({"success": False, "message": f"Échec de la récupération des fichiers: {file_message}"}), 500
+    else:
+        # Trier et structurer les données de fichiers pour le frontend
+        # (Vous pouvez implémenter un tri par type/nom ici si nécessaire)
+        response_data['file_list'] = file_list
+        
+    # 3. Récupérer le contenu du README.md
+    readme_path = f"{user_id}/{repo_slug}/README.md"
+    readme_content, readme_message = get_file_content_from_hf(readme_path)
+
+    if readme_content:
+        response_data['readme_content'] = readme_content
+    else:
+        # README.md est optionnel
+        logger.info(f"README.md non trouvé ou erreur pour {user_id}/{repo_slug}: {readme_message}")
+        response_data['readme_content'] = f"Pas de fichier README.md trouvé pour le dépôt {repo_slug}."
+
+    # 4. Succès
+    return jsonify({"success": True, "data": response_data}), 200
+
+@project_bp.route("/api/file_content/<repo_slug>", methods=["GET"])
+@api_session_required
+def get_file_content_api(repo_slug, client_user):
+    """
+    Route API pour récupérer le contenu d'un fichier spécifique dans un dépôt.
+    URL: /api/file_content/<repo_slug>?path=<file_path>
+    """
+    # Récupérer l'ID utilisateur depuis le décorateur de session
+    user_id = client_user.get('user_id')
+    # Récupérer le chemin du fichier depuis le paramètre de requête 'path'
+    file_path = request.args.get('path')
+
+    if not user_id:
+        return jsonify({"success": False, "message": "Unauthorized. Missing user ID in session."}), 401
+    
+    if not file_path:
+        return jsonify({"success": False, "message": "Missing 'path' query parameter."}), 400
+
+    # 1. Définir le préfixe de base du dépôt attendu dans le repo HF
+    repo_base_prefix = f"{user_id}/{repo_slug}/"
+
+    
+    # Si le chemin reçu commence déjà par le préfixe du repo, on l'utilise tel quel.
+    if file_path.startswith(repo_base_prefix):
+        file_path_in_repo = file_path
+    # Si le chemin ne contient QUE le nom du fichier (Ex: Entreprises.html)
+    # ou un chemin relatif à la racine du dépôt (Ex: css/style.css), on le construit.
+    else:
+        file_path_in_repo = f"{user_id}/{repo_slug}/{file_path}"
+        
+    
+    # 1. Vérifie si le chemin contient l'ID du dataset principal dans sa structure
+    if "datasets/" in file_path:
+        # Tenter d'extraire la partie 'user_id/repo_slug/fichier'
+        try:
+            
+            # Solution la plus simple et la plus fiable si le front-end envoie un chemin partiel (ex: 'Entreprises.html'):
+            file_path_in_repo = f"{user_id}/{repo_slug}/{file_path.split('/')[-1]}"
+            
+        except:
+             # Si l'extraction échoue, on revient à la construction simple
+             file_path_in_repo = f"{user_id}/{repo_slug}/{file_path}"
+             
+    # 2. Si le front-end a envoyé le chemin complet (user_id/repo_slug/fichier.ext), on l'utilise
+    elif file_path.startswith(user_id):
+        file_path_in_repo = file_path
+    
+    # 3. Si le front-end a envoyé le chemin relatif (fichier.ext), on le construit
+    else:
+        file_path_in_repo = f"{user_id}/{repo_slug}/{file_path}"
+
+
+    # Appel de la fonction manager avec le chemin complet
+    # Note : La fonction n'attend qu'un seul argument de chemin
+    file_content, error_message = get_file_content_from_hf(
+        file_path_in_repo=file_path_in_repo,
+        repo_id=None # Utiliser la valeur par défaut HF_DATASET_REPO_ID dans la fonction
+    )
+
+
+    if file_content is not None:
+        # Succès
+        return jsonify({
+            "success": True,
+            "file_content": file_content
+        }), 200
+    else:
+        # Échec
+        # Utiliser un code 404 si le fichier n'existe pas, 500 pour les autres erreurs
+        status_code = 404 if "non trouvé" in error_message.lower() or "not found" in error_message.lower() else 500
+        return jsonify({"success": False, "message": f"Failed to retrieve file content: {error_message}"}), status_code
+
+# PAR CES TROIS LIGNES:
+# 1. Gère /live/<repo_slug> (sans slash final) -> Doit rediriger.
+@project_bp.route("/live/<repo_slug>", methods=["GET"], defaults={'file_path': ''}) 
+# 2. Gère /live/<repo_slug>/ (avec slash final, la racine du site) -> Sert index.html.
+@project_bp.route("/live/<repo_slug>/", methods=["GET"], defaults={'file_path': 'index.html'}) 
+# 3. Gère /live/<repo_slug>/file.html (tous les autres fichiers).
+@project_bp.route("/live/<repo_slug>/<path:file_path>", methods=["GET"])
+def get_live_deployment(repo_slug, file_path):
+    """
+    Route simulant le déploiement en direct d'un site statique.
+    """
+    
+    # NOUVEAU: 1. VÉRIFIER ET FORCER LA BARRE OBLIQUE (TRAILING SLASH)
+    # Cette vérification ne se déclenchera que si la première route est utilisée.
+    if not file_path and not request.path.endswith('/'):
+        # Rediriger vers l'URL avec un slash final. Ex: /live/slug -> /live/slug/
+        # url_for génère correctement la nouvelle URL qui correspondra à la route #2.
+        return redirect(url_for('.get_live_deployment', repo_slug=repo_slug), code=302)
+        
+    # Tenter de récupérer l'ID de l'utilisateur connecté (propriétaire)
+    user_id = session.get('user_id')
+    
+    if not user_id:
+        # Pour une démo de site statique public, cette vérification est problématique si l'utilisateur est déconnecté.
+        # Pour l'instant, nous la gardons pour la sécurité mais cela peut causer le 404 si l'utilisateur n'est pas loggé.
+        return "Erreur 401: Non autorisé. ID utilisateur manquant dans la session. (Connexion requise).", 401
+        
+    
+    # 2. Déterminer le nom du fichier à charger
+    # Si la route par défaut 2 a été utilisée, file_path est 'index.html'. Sinon, il contient le chemin complet.
+    file_to_load = file_path.lstrip('/')
+        
+    # 3. Définir le chemin complet du fichier dans le repo HF
+    # Structure: user_id/repo_slug/file_to_load
+    hf_file_path = f"{user_id}/{repo_slug}/{file_to_load}"
+    
+    # 4. Récupérer le contenu
+    content, message = get_file_content_from_hf(hf_file_path)
+
+    if content:
+        # 5. Retourner le contenu HTML brut
+        return content, 200, {'Content-Type': 'text/html'}
+    else:
+        # Gérer l'erreur de fichier non trouvé
+        logger.error(f"Échec du déploiement en direct pour {repo_slug} ({file_to_load}): {message}")
+        
+        return render_template(
+            "deployment_error.html", 
+            message=f"Impossible de trouver le fichier {file_to_load} dans le dépôt '{repo_slug}'.",
+            repo_slug=repo_slug
+        ), 404
+
+
+@project_bp.route("/mindus/nexus/commit_file", methods=["POST"])
+@api_session_required
+def commit_file(client_user): # <-- AJOUTER 'client_user' ici
+    """
+    Crée ou met à jour un fichier dans un dépôt d'utilisateur sur HF.
+    """
+    # Utiliser l'ID fourni par le décorateur, ou session si besoin
+    user_id = client_user.get('user_id') 
+    data = request.json
+
+    # Validation des données (user_id est maintenant mieux géré)
+    repo_slug = data.get('repo_slug')
+    file_path = data.get('file_path')        # Chemin relatif (ex: 'index.html')
+    file_content = data.get('file_content')
+    commit_title = data.get('commit_title', f"Update {file_path}") # Message de commit
+
+    # Note: On laisse la validation sur user_id même si le décorateur l'a vérifié, par sécurité
+    if not all([user_id, repo_slug, file_path, file_content]):
+        return jsonify({"success": False, "message": "Missing required fields (repo_slug, file_path, file_content). A valid user session is also required."}), 400
+
+    # Note: Dans un environnement réel, on vérifierait si le commit_title est vide, etc.
+
+    success, message = commit_file_to_hf(
+        repo_slug=repo_slug,
+        user_id=user_id,
+        file_path=file_path,
+        file_content=file_content,
+        commit_message=commit_title
+    )
+
+    if success:
+        # Répondre avec un message de succès
+        return jsonify({"success": True, "message": "File committed successfully."}), 200
+    else:
+        # En cas d'échec du commit (400 si c'est un conflit/erreur utilisateur, 500 pour une erreur serveur)
+        # Simplification: on renvoie 500 pour toute erreur d'API pour l'instant.
+        return jsonify({"success": False, "message": f"Commit failed: {message}"}), 500
+
+
+@project_bp.route("/mindus/nexus/list_repo_files/<repo_slug>", methods=["GET"])
+@api_session_required
+def list_repo_files_api(repo_slug, client_user): # <-- AJOUTER 'client_user' ici
+    """
+    Liste les fichiers dans un dépôt d'utilisateur spécifique.
+    """
+    # Utiliser l'ID fourni par le décorateur
+    user_id = client_user.get('user_id')
+
+    if not user_id:
+        return jsonify({"success": False, "message": "Unauthorized. Missing user ID in session."}), 401
+
+    # Le chemin dans le HF Dataset est user_id/repo_slug
+    repo_path_on_hf = f"{user_id}/{repo_slug}"
+
+    # Utilise la fonction list_repo_files_from_hf existante
+    # CORRECTION : La fonction list_repo_files_from_hf prend user_id et repo_slug séparemment
+    file_list, message = list_repo_files_from_hf(repo_slug, user_id)
+
+    if file_list is not None:
+        # Le contenu de file_list est déjà une liste de strings
+        return jsonify({"success": True, "files": file_list}), 200
+    else:
+        # Gérer l'erreur de fichier non trouvé (souvent un 404 pour un repo inexistant ou vide)
+        # Simplification: 404 si la liste est None
+        return jsonify({"success": False, "message": f"Failed to list files: {message}"}), 404
+
+
+@project_bp.route('/mindus/nexus/save_file_content', methods=['POST'])
+@login_required
+@api_session_required
+def save_file_content(client_user=None): # <-- CORRECTION APPLIQUÉE ICI
+    """Route API pour créer manuellement un nouveau fichier ou sauvegarder un fichier existant 
+    dans un dépôt spécifique via le repo_slug."""
+    
+    # 1. Récupération de l'ID utilisateur
+    # Note: On peut garder la récupération depuis session pour être cohérent avec l'ancienne logique
+    # (ou utiliser client_user si vos décorateurs fournissent l'ID directement).
+    user_id = session.get('user_id') 
+    if not user_id:
+        # Ceci ne devrait normalement pas arriver si @login_required fonctionne correctement
+        return jsonify({"success": False, "error": "Session invalide ou authentification requise."}), 401
+    
+    data = request.get_json()
+    
+    # 2. Récupération des données du corps de la requête (JSON)
+    repo_slug = data.get('repo_slug')       # Le slug du dépôt (ex: 'mailix')
+    file_path = data.get('file_path')       # Le chemin du fichier (ex: 'nouveau.md' ou 'src/config.json')
+    file_content = data.get('file_content') # Le contenu complet à sauvegarder
+    
+    # Message de commit par défaut, si non fourni par le frontend
+    commit_message = data.get('commit_message', f"Commit via editor: Sauvegarde de {file_path}")
+    
+    if not all([repo_slug, file_path, file_content]):
+        return jsonify({"success": False, "error": "Paramètres manquants: 'repo_slug', 'file_path', et 'file_content' sont requis."}), 400
+
+    # 3. Appel de la fonction de sauvegarde
+    success, message = save_file_content_to_hf(
+        user_id=user_id,
+        repo_slug=repo_slug,
+        file_path=file_path,
+        file_content=file_content,
+        commit_message=commit_message 
+        # repo_id, repo_type et branch utiliseront les valeurs par défaut ou de configuration
+    )
+    
+    # 4. Réponse au frontend
+    if success:
+        return jsonify({"success": True, "message": message}), 200
+    else:
+        # Si save_file_content_to_hf retourne False, on renvoie l'erreur détaillée
+        return jsonify({"success": False, "error": message}), 500
+
+@project_bp.route('/api/files/<repo_slug>/delete', methods=['POST'])
+@api_session_required
+def delete_file_from_repo(client_user, repo_slug):
+    """
+    Gère la suppression d'un fichier spécifique du dépôt utilisateur sur Hugging Face.
+    Nécessite 'file_path' dans le corps JSON de la requête.
+    """
+    user_id = client_user.get('user_id')
+    
+    if not user_id:
+        return jsonify({"success": False, "message": "Erreur d'authentification: ID utilisateur manquant."}), 401
+    
+    data = request.get_json()
+    file_path = data.get('file_path')
+    
+    if not file_path:
+        return jsonify({"success": False, "message": "Le chemin du fichier ('file_path') est obligatoire pour la suppression."}), 400
+
+    # Message de commit par défaut
+    commit_message = data.get('commit_message', f"Delete file: {file_path}")
+
+    # --- ÉTAPE CLÉ : Appel de la nouvelle fonction du backend ---
+    success, message = delete_file_from_hf_repo(
+        repo_slug=repo_slug,
+        user_id=user_id,
+        file_path=file_path,
+        commit_message=commit_message
+    )
+    
+    if success:
+        logger.info(f"Fichier {file_path} supprimé du dépôt {repo_slug} par {user_id}.")
+        return jsonify({
+            "success": True, 
+            "message": message,
+        }), 200
+    else:
+        logger.error(f"Échec de la suppression du fichier {file_path} pour {user_id}/{repo_slug}: {message}")
+        # Statut 500 pour Erreur Serveur Interne si la suppression backend échoue
+        return jsonify({"success": False, "message": message}), 500
+
+# project_routes.py (après les routes existantes)
+
+@project_bp.route("/apply", methods=["POST"])
+def submit_application():
+    """
+    Route publique pour soumettre une candidature.
+    
+    Attend une requête multipart/form-data contenant :
+    - 'application_json': une chaîne JSON des données du formulaire.
+    - 'document_file': le fichier PDF ou DOCX.
+    """
+    
+    # 1. Générer un ID unique pour cette candidature
+    application_id = str(uuid.uuid4())
+    
+    # 2. Extraction et validation des données de la requête
+    
+    # Récupérer le fichier
+    document_file = request.files.get('document_file')
+    if not document_file or document_file.filename == '':
+        return jsonify({"success": False, "message": "Le fichier de candidature ('document_file') est manquant."}), 400
+
+    # Récupérer les données JSON
+    application_json_str = request.form.get('application_json')
+    if not application_json_str:
+        return jsonify({"success": False, "message": "Les données du formulaire ('application_json') sont manquantes."}), 400
+    
+    try:
+        application_data = json.loads(application_json_str)
+    except json.JSONDecodeError:
+        return jsonify({"success": False, "message": "Format JSON des données de candidature invalide."}), 400
+
+    # Validation du type de fichier (PDF ou DOCX)
+    allowed_extensions = ['.pdf', '.docx']
+    file_ext = os.path.splitext(document_file.filename)[1].lower()
+    if file_ext not in allowed_extensions:
+        return jsonify({"success": False, "message": f"Type de fichier non supporté. Seuls {', '.join(allowed_extensions)} sont autorisés."}), 400
+
+    # 3. Préparer les données pour la sauvegarde
+    application_data['application_id'] = application_id
+    application_data['submission_date'] = datetime.now().isoformat()
+    application_data['document_filename'] = document_file.filename
+    application_data['document_hf_path'] = f"document_applications/{application_id}{file_ext}" # Chemin pour référence dans le JSON
+
+    # --- 4. Sauvegarde du document (PDF/DOCX) sur IMAGE_STORAGE_HF_REPO_ID ---
+    doc_success, doc_message = upload_application_document_to_hf(
+        file_storage_obj=document_file,
+        application_id=application_id,
+        file_extension=file_ext,
+    )
+    
+    if not doc_success:
+        logger.error(f"Échec du téléversement du document {application_id}: {doc_message}")
+        return jsonify({"success": False, "message": f"Échec du téléversement du document. Détail: {doc_message}"}), 500
+
+    # --- 5. Sauvegarde des données JSON du formulaire sur HF_DATASET_REPO_ID ---
+    json_success, json_message = save_application_json_to_hf(
+        application_data=application_data,
+        application_id=application_id,
+    )
+
+    if not json_success:
+        logger.error(f"Échec de la sauvegarde du JSON pour {application_id}: {json_message}")
+        # NOTE: Dans un cas réel, on essaierait de supprimer le document qui a réussi le téléversement (étape 4)
+        # pour éviter d'avoir un document sans données de formulaire, mais on se contente ici de notifier l'échec.
+        return jsonify({"success": False, "message": f"Échec de la sauvegarde des données du formulaire. Détail: {json_message}"}), 500
+        
+    logger.info(f"Candidature complète soumise avec ID: {application_id}")
+    return jsonify({
+        "success": True, 
+        "message": "Votre candidature a été soumise avec succès.", 
+        "application_id": application_id
+    }), 200
+
+# Dans project_routes.py
+
+@project_bp.route("/submit_application_data", methods=["POST"])
+def submit_application_data_only():
+    """
+    Route publique pour soumettre uniquement les données textuelles/JSON d'une candidature 
+    (par exemple, si aucun CV/document n'est requis pour cette étape).
+    
+    Attend une requête POST avec un corps de requête JSON.
+    """
+    
+    # 1. Générer un ID unique pour cette candidature
+    application_id = str(uuid.uuid4())
+    
+    # 2. Extraction des données JSON du corps de la requête
+    # 'request.get_json()' permet de lire directement le corps JSON
+    application_data = request.get_json(silent=True)
+    
+    if not application_data or not isinstance(application_data, dict):
+        # Utiliser 'request.get_json(silent=True)' pour éviter une erreur si le Content-Type n'est pas bon
+        return jsonify({"success": False, "message": "Les données JSON du formulaire sont manquantes, invalides ou le 'Content-Type' n'est pas 'application/json'."}), 400
+
+    # 3. Préparer les données pour la sauvegarde
+    application_data['application_id'] = application_id
+    application_data['submission_date'] = datetime.now().isoformat()
+    # Ajout d'un champ pour indiquer qu'il n'y a pas de document
+    application_data['document_filename'] = "No document attached"
+    application_data['document_hf_path'] = None 
+
+    # --- 4. Sauvegarde des données JSON du formulaire sur HF_DATASET_REPO_ID ---
+    json_success, json_message = save_application_json_to_hf(
+        application_data=application_data,
+        application_id=application_id,
+        commit_message=f"Ajout des données de candidature (JSON seulement): {application_id}"
+    )
+
+    if not json_success:
+        logger.error(f"Échec de la sauvegarde du JSON pour {application_id}: {json_message}")
+        return jsonify({"success": False, "message": f"Échec de la sauvegarde des données du formulaire. Détail: {json_message}"}), 500
+        
+    logger.info(f"Candidature (données seulement) soumise avec ID: {application_id}")
+    return jsonify({
+        "success": True, 
+        "message": "Vos données de formulaire ont été soumises avec succès.", 
+        "application_id": application_id
+    }), 200
+
+@project_bp.route('/api/repos/<repo_slug>', methods=['DELETE'])
+@api_session_required
+def delete_repo(client_user, repo_slug):
+    """
+    Gère la suppression complète d'un dépôt (dossier récursif) sur Hugging Face
+    et la mise à jour des métadonnées de l'utilisateur.
+    """
+    user_id = client_user.get('user_id')
+    
+    if not user_id:
+        return jsonify({"success": False, "message": "Erreur d'authentification: ID utilisateur manquant."}), 401
+    
+    if not repo_slug:
+         return jsonify({"success": False, "message": "Le slug du dépôt est manquant."}), 400
+
+    # 1. Récupérer le 'deploy_id' du dépôt à partir des métadonnées
+    # Nous avons besoin de cet ID pour identifier la bonne entrée dans le fichier metadata.json.
+    try:
+        metadata, _ = get_user_repo_metadata(user_id)
+        repo_to_delete = next(
+            (repo for repo in metadata.get("repos", []) if repo.get("repo_slug") == repo_slug), 
+            None
+        )
+
+        if not repo_to_delete:
+            return jsonify({"success": False, "message": f"Dépôt '{repo_slug}' non trouvé dans les métadonnées de l'utilisateur."}), 404
+
+        deploy_id = repo_to_delete.get("FIELD_DEPLOY_ID")
+        
+    except Exception as e:
+        logger.error(f"Erreur lors de la récupération des métadonnées pour supprimer {repo_slug}: {e}")
+        return jsonify({"success": False, "message": "Erreur interne lors de la lecture des métadonnées."}), 500
+
+    # 2. Appel de la fonction du backend pour la suppression
+    try:
+        success, message = delete_repo_folder_from_hf(
+            repo_slug=repo_slug,
+            user_id=user_id,
+            deploy_id=deploy_id,
+            commit_message=f"Suppression complète du dépôt {repo_slug} par l'utilisateur."
+            # repo_id sera utilisé par défaut (HF_DATASET_REPO_ID)
+        )
+
+        if success:
+            logger.info(f"Dépôt {repo_slug} supprimé avec succès par {user_id}.")
+            return jsonify({"success": True, "message": message}), 200
+        else:
+            logger.error(f"Échec de la suppression du dépôt {repo_slug}: {message}")
+            return jsonify({"success": False, "message": message}), 500 # 500 pour Erreur Serveur Interne
+
+    except Exception as e:
+        logger.exception(f"Erreur inattendue lors de la suppression du dépôt pour {user_id}/{repo_slug}: {e}")
+        return jsonify({"success": False, "message": f"Erreur interne: {str(e)}"}), 500
+
+@project_bp.route("/mindus/nexus/repo_settings/<repo_slug>", methods=["GET"])
+@login_required
+def get_repo_settings_page(repo_slug):
+    """
+    Route (SSR) pour afficher la page des paramètres du dépôt (secrets/variables).
+    Nécessite 'repo_slug' en paramètre.
+    """
+    user_id = session.get('user_id')
+    
+    if not repo_slug:
+        flash("Dépôt non spécifié pour les paramètres.", "error")
+        return redirect(url_for('user_bp.dashboard')) 
+
+    # Charger les données utilisateur (pour le contexte Jinja2)
+    user_data = get_user_by_id(user_id)
+    
+    return render_template(
+        'repo_settings.html', # Assumer l'existence de ce template
+        user=user_data, 
+        repo_slug=repo_slug 
+    )
+
+@project_bp.route('/api/repo_data/<repo_slug>/items', methods=['GET'])
+@api_session_required
+def get_repo_items_api(client_user, repo_slug):
+    """
+    Récupère la liste des secrets ou des variables pour un dépôt spécifié.
+    Utilise le paramètre de requête 'item_type' ('secret' ou 'variable').
+    """
+    user_id = client_user.get('user_id')
+    # Récupérer le type d'élément depuis les paramètres de requête
+    item_type = request.args.get('item_type') 
+    
+    if not user_id:
+        return jsonify({"success": False, "message": "Erreur d'authentification: ID utilisateur manquant."}), 401
+    
+    if item_type not in ['secret', 'variable']:
+        return jsonify({"success": False, "message": "Type d'élément non valide. Utilisez 'secret' ou 'variable'."}), 400
+
+    try:
+        # Appel de la fonction manager
+        items_list, message = get_repo_secrets_or_variables(
+            user_id=user_id,
+            repo_slug=repo_slug,
+            item_type=item_type
+        )
+        
+        # Note: Si c'est un secret, la valeur est masquée par le backend.
+        return jsonify({"success": True, "items": items_list, "message": message}), 200
+        
+    except Exception as e:
+        logger.exception(f"Erreur lors de la récupération des {item_type}s pour {user_id}/{repo_slug}: {e}")
+        return jsonify({"success": False, "message": f"Erreur interne lors de l'accès aux {item_type}s: {str(e)}"}), 500
+
+@project_bp.route('/api/repo_data/<repo_slug>/update_item', methods=['POST'])
+@api_session_required
+def update_repo_item_api(client_user, repo_slug):
+    """
+    Crée ou met à jour un secret ou une variable (basé sur le nom) pour un dépôt spécifié.
+    Les données requises sont envoyées en JSON.
+    """
+    user_id = client_user.get('user_id')
+    data = request.get_json()
+    
+    if not user_id:
+        return jsonify({"success": False, "message": "Erreur d'authentification: ID utilisateur manquant."}), 401
+
+    # Récupération des données du corps JSON
+    item_type = data.get('item_type') # 'secret' ou 'variable'
+    name = data.get('name')
+    value = data.get('value')
+    description = data.get('description') # Optionnel
+    
+    if item_type not in ['secret', 'variable']:
+        return jsonify({"success": False, "message": "Type d'élément non valide. Utilisez 'secret' ou 'variable'."}), 400
+
+    if not all([name, value]):
+        return jsonify({"success": False, "message": "Les champs 'name' et 'value' sont obligatoires."}), 400
+
+    try:
+        # Appel de la fonction manager pour la mise à jour atomique
+        success, message = update_repo_secrets_or_variables(
+            user_id=user_id,
+            repo_slug=repo_slug,
+            item_type=item_type,
+            name=name,
+            value=value,
+            description=description
+        )
+        
+        if success:
+            return jsonify({"success": True, "message": message}), 201
+        else:
+            return jsonify({"success": False, "message": message}), 500
+            
+    except Exception as e:
+        logger.exception(f"Erreur inattendue lors de la mise à jour du {item_type} pour {user_id}/{repo_slug}: {e}")
+        return jsonify({"success": False, "message": f"Erreur interne lors de la mise à jour: {str(e)}"}), 500
+
+# Route pour SUPPRIMER un secret/variable (DELETE)
+@project_bp.route('/api/repo_data/<repo_slug>/items', methods=['DELETE'])
+@api_session_required
+def delete_repo_item_api(client_user, repo_slug):
+    """
+    Supprime un secret ou une variable pour un dépôt donné.
+    Paramètres de requête requis : item_type ('secret' ou 'variable') et name.
+    URL appelée par le front-end : /api/repo_data/<repo_slug>/items?item_type=secret&name=MON_SECRET
+    """
+    user_id = client_user.get('user_id')
+    
+    # Récupération des paramètres de requête (query parameters)
+    item_type = request.args.get('item_type') # 'secret' ou 'variable'
+    name = request.args.get('name')           # Nom de l'élément à supprimer
+
+    if not user_id:
+        return jsonify({"success": False, "message": "Erreur d'authentification: ID utilisateur manquant."}), 401
+
+    if item_type not in ['secret', 'variable']:
+        return jsonify({"success": False, "message": "Le paramètre 'item_type' est invalide. Utilisez 'secret' ou 'variable'."}), 400
+
+    if not name:
+        return jsonify({"success": False, "message": "Le paramètre 'name' de l'élément à supprimer est manquant."}), 400
+
+    try:
+        # Appel de la fonction de suppression
+        # (Nécessite que delete_repo_secret_or_variable soit bien importée en haut du fichier)
+        success, message = delete_repo_secret_or_variable(
+            user_id=user_id,
+            repo_slug=repo_slug,
+            item_type=item_type,
+            name=name
+        )
+        
+        if success:
+            logger.info(f"Suppression réussie du {item_type} '{name}' pour {repo_slug}.")
+            return jsonify({"success": True, "message": message}), 200 # 200 OK pour une suppression réussie
+        else:
+            logger.error(f"Échec de la suppression du {item_type} '{name}' pour {repo_slug}: {message}")
+            # Si l'élément n'est pas trouvé, on peut renvoyer 404 (mais 500 pour les autres erreurs backend)
+            return jsonify({"success": False, "message": message}), 500 
+
+    except Exception as e:
+        logger.exception(f"Erreur interne lors de la suppression du {item_type} pour {repo_slug}: {e}")
+        return jsonify({"success": False, "message": f"Erreur interne du serveur: {str(e)}"}), 500

a6ea61c8-951a-413a-ba9d-7365d83fbd4d/mayproject/pull_request_backend.py

@@ -0,0 +1,607 @@
+# pull_request_backend.py (Mise à jour pour autonomie)
+
+import uuid
+from datetime import datetime
+import logging
+from typing import Optional, Dict, List
+from io import BytesIO # NOUVEL IMPORT pour la manipulation des fichiers
+
+# Importations spécifiques à Hugging Face pour l'autonomie
+from huggingface_hub import HfApi, HfFileSystem, CommitOperationAdd 
+from huggingface_hub.utils import HfHubHTTPError # CORRECTION: Import de l'exception depuis 'huggingface_hub.utils'
+
+# Importations des variables de configuration
+from config import (
+    PULL_REQUESTS_HF_REPO_ID,
+    HF_DATASET_REPO_ID,
+    # IMAGE_STORAGE_HF_REPO_ID, # Non utilisé directement ici
+    HF_TOKEN # Utile pour l'API
+)
+
+# --- Initialisation de l'API et du FileSystem ---
+api = HfApi(token=HF_TOKEN) # NOUVEAU : Initialisation de l'API HF
+fs = HfFileSystem(token=HF_TOKEN) # NOUVEAU : Initialisation du FileSystem HF
+
+# Nouvelle structure d'importation pour l'autonomie des fonctions de branche :
+from huggingface_repo_manager import (
+    load_json_file_from_hf,
+    save_json_file_to_hf,
+    get_diff_between_branches,
+    check_for_conflicts,
+    execute_merge_commit,
+    get_user_repo_metadata,
+)
+
+PR_DATA_FOLDER_NAME = "pr_data"
+
+logger = logging.getLogger(__name__)
+
+# --- Constantes ---
+PR_FILE_PATH_TEMPLATE = "pr_data/{user_id}/{repo_slug}/prs.json"
+
+# --- Fonctions de Métadonnées (Interaction avec prs.json) ---
+
+def _get_pr_file_path(repo_slug: str, user_id: str) -> str:
+    """Construit le chemin d'accès au fichier prs.json."""
+    return PR_FILE_PATH_TEMPLATE.format(user_id=user_id, repo_slug=repo_slug)
+
+def load_all_prs_from_hf(repo_slug: str, user_id: str) -> List[Dict]:
+    """Charge l'intégralité du fichier prs.json du dépôt spécifié."""
+    if not PULL_REQUESTS_HF_REPO_ID:
+        # Erreur de configuration
+        return []
+
+    file_path = _get_pr_file_path(repo_slug, user_id)
+
+    pr_data, msg = load_json_file_from_hf(
+        file_path=file_path,
+        repo_id=PULL_REQUESTS_HF_REPO_ID
+    )
+
+    # Si le fichier n'existe pas ou erreur, on retourne une liste vide.
+    if pr_data is None or "prs" not in pr_data:
+        return []
+
+    return pr_data.get("prs", [])
+
+# NOUVEAU CODE (RÉSOUD LE PROBLÈME) :
+def _get_user_repository_slugs_placeholder(user_id: str) -> List[str]:
+    """
+    RÉSOLUTION DU PROBLÈME : Récupère la liste réelle des slugs de dépôts de l'utilisateur
+    à partir des métadonnées stockées sur Hugging Face (via get_user_repo_metadata).
+
+    Ceci rend la fonction 'load_all_user_prs' beaucoup plus robuste.
+    """
+    try:
+        # NOTE: get_user_repo_metadata est la fonction qui lit le fichier
+        # des métadonnées utilisateur pour trouver les dépôts.
+        metadata, _ = get_user_repo_metadata(user_id)
+    except Exception as e:
+        # En cas d'échec de la lecture ou d'erreur API, on logge et retourne []
+        # logger.error(f"Échec de la récupération des métadonnées pour charger les PRs: {e}")
+        return []
+
+    # Les données utilisateur contiennent une liste de dépôts sous la clé 'repos'.
+    if metadata and isinstance(metadata.get("repos"), list):
+        # Extrait et retourne uniquement les slugs (repo_slug) de tous les dépôts trouvés.
+        return [repo.get('repo_slug') for repo in metadata["repos"] if repo.get('repo_slug')]
+
+    return [] # Retourne une liste vide si aucun dépôt n'est trouvé.
+
+def load_all_user_prs(user_id: str) -> List[Dict]:
+    """
+    Charge toutes les Pull Requests pour TOUS les dépôts appartenant à un utilisateur.
+    Utilisé pour le tableau de bord (dashboard).
+    """
+    all_prs: List[Dict] = []
+
+    # 1. Récupérer la liste des slugs de dépôts de l'utilisateur
+    repo_slugs = _get_user_repository_slugs_placeholder(user_id)
+
+    for repo_slug in repo_slugs:
+        # 2. Réutiliser la fonction existante pour charger les PRs d'un seul dépôt
+        try:
+            prs_for_repo = load_all_prs_from_hf(repo_slug, user_id)
+        except Exception as e:
+            # Gérer les cas où le fichier prs.json n'existe pas pour un repo
+            logger.warning(f"Impossible de charger les PRs pour le dépôt {repo_slug}: {e}")
+            continue
+
+        # 3. Ajouter le repo_slug à chaque PR (essentiel pour l'affichage dashboard)
+        for pr in prs_for_repo:
+            pr['repo_slug'] = repo_slug
+            all_prs.append(pr)
+
+    return all_prs
+
+def save_all_prs_to_hf(repo_slug: str, user_id: str, pr_list: List[Dict]) -> tuple[bool, str]:
+    """Sérialise et enregistre la liste complète des PR dans le fichier prs.json."""
+    if not PULL_REQUESTS_HF_REPO_ID:
+        return False, "Erreur de configuration: PULL_REQUESTS_HF_REPO_ID manquant."
+
+    file_path = _get_pr_file_path(repo_slug, user_id)
+    data_to_save = {"prs": pr_list}
+    commit_msg = f"Mise à jour des métadonnées des PR pour {repo_slug}."
+
+    return save_json_file_to_hf(
+        file_path=file_path,
+        data=data_to_save,
+        commit_message=commit_msg,
+        repo_id=PULL_REQUESTS_HF_REPO_ID
+    )
+
+def create_pull_request(
+    repo_slug: str,
+    source_branch: str,
+    target_branch: str,
+    title: str,
+    description: str,
+    user_id: str
+) -> tuple[Optional[str], str]:
+    """
+    Crée et enregistre une nouvelle PR.
+    Le processus inclut l'initialisation de la branche source de PR
+    (copie du contenu du dépôt principal).
+    """
+
+    pr_id = str(uuid.uuid4())[:8] # ID court
+
+    # --- NOUVELLE VÉRIFICATION DE LA CONVENTION DE BRANCHE CIBLE ---
+    # Selon la nouvelle convention, la branche cible (principale) est le repo_slug lui-même.
+    if target_branch != repo_slug:
+        # On force la valeur à la convention structurelle.
+        logger.warning(f"Target branch ajustée de '{target_branch}' au repo_slug '{repo_slug}'.")
+        target_branch = repo_slug
+
+    # 1. CRÉATION ET INITIALISATION DE LA BRANCHE DE PR (source_branch)
+    # L'étape cruciale : copier les fichiers du dépôt de base vers le chemin isolé de la PR.
+    # Cette fonction est maintenant définie dans ce fichier.
+    branch_success, branch_msg = create_new_pr_branch(
+        user_id=user_id,
+        repo_slug=repo_slug,
+        new_branch_name=source_branch
+    )
+
+    if not branch_success:
+        # Si la copie des fichiers échoue, on arrête la création de la PR.
+        return None, f"Échec de l'initialisation de la branche de PR '{source_branch}': {branch_msg}"
+
+    # 2. Charger la liste existante des métadonnées de PR
+    pr_list = load_all_prs_from_hf(repo_slug, user_id)
+
+    new_pr = {
+        "pr_id": pr_id,
+        "repo_slug": repo_slug,
+        "source_branch": source_branch, # Ex: 'feature-x'
+        "target_branch": target_branch, # Ex: 'mon-depot-slug'
+        "title": title,
+        "description": description,
+        "status": "Open",
+        "created_by": user_id,
+        "created_at": datetime.utcnow().isoformat(),
+        "merged_at": None,
+        "closed_at": None,
+    }
+
+    # 3. Ajouter la nouvelle PR à la liste des métadonnées
+    pr_list.append(new_pr)
+
+    # 4. Enregistrer la liste mise à jour des métadonnées de PR
+    success, msg = save_all_prs_to_hf(repo_slug, user_id, pr_list)
+
+    if success:
+        return pr_id, f"Pull Request créée avec succès. La branche '{source_branch}' est prête pour les modifications."
+    else:
+        # La branche a été créée, mais l'enregistrement de la PR a échoué.
+        return None, f"Échec de l'enregistrement des métadonnées de la PR: {msg}. La branche a été créée, mais la PR n'est pas tracée."
+
+def get_pull_request_by_id(pr_id: str, repo_slug: str, user_id: str) -> Optional[Dict]:
+    """Récupère une PR spécifique par son ID."""
+    pr_list = load_all_prs_from_hf(repo_slug, user_id)
+    return next((pr for pr in pr_list if pr['pr_id'] == pr_id), None)
+
+def update_pull_request_status(pr_id: str, repo_slug: str, user_id: str, new_status: str) -> tuple[bool, str]:
+    """Met à jour l'état (Open, Closed, Merged) d'une PR existante."""
+    pr_list = load_all_prs_from_hf(repo_slug, user_id)
+
+    pr_to_update = next((pr for pr in pr_list if pr['pr_id'] == pr_id), None)
+
+    if pr_to_update is None:
+        return False, f"Pull Request ID {pr_id} non trouvée."
+
+    pr_to_update['status'] = new_status
+
+    if new_status == "Closed":
+        pr_to_update['closed_at'] = datetime.utcnow().isoformat()
+    elif new_status == "Merged":
+        pr_to_update['merged_at'] = datetime.utcnow().isoformat()
+
+    return save_all_prs_to_hf(repo_slug, user_id, pr_list)
+
+# --- Fonctions Cœur de Git/Hugging Face (Appels au Storage) ---
+
+def get_pr_diff(repo_slug: str, user_id: str, pr_id: str) -> tuple[Optional[Dict], str]:
+    """Calcule et retourne la liste des fichiers modifiés et les différences pour une PR."""
+    pr = get_pull_request_by_id(pr_id, repo_slug, user_id)
+    if not pr:
+        return None, f"Pull Request ID {pr_id} introuvable."
+
+    # Appel à la fonction de stockage
+    return get_diff_between_branches(
+        repo_slug,
+        user_id,
+        pr['source_branch'],
+        pr['target_branch']
+    )
+
+def check_pr_merge_status(repo_slug: str, user_id: str, pr_id: str) -> tuple[bool, List[str], str]:
+    """Vérifie les conflits pour une PR."""
+    pr = get_pull_request_by_id(pr_id, repo_slug, user_id)
+    if not pr:
+        return False, [], f"Pull Request ID {pr_id} introuvable."
+
+    # Appel à la fonction de stockage
+    return check_for_conflicts(
+        repo_slug,
+        user_id,
+        pr['source_branch'],
+        pr['target_branch']
+    )
+
+def merge_pull_request(pr_id: str, repo_slug: str, user_id: str, committer_id: str) -> tuple[bool, str]:
+    """Exécute la fusion et met à jour le statut."""
+    pr = get_pull_request_by_id(pr_id, repo_slug, user_id)
+    if not pr:
+        return False, f"Pull Request ID {pr_id} introuvable."
+
+    if pr['status'] != 'Open':
+        return False, f"La PR n'est pas ouverte (Statut actuel: {pr['status']})."
+
+    # 1. Vérification finale des conflits
+    can_merge, conflicts, msg = check_pr_merge_status(repo_slug, user_id, pr_id)
+
+    if not can_merge:
+        return False, f"Impossible de fusionner en raison de conflits: {', '.join(conflicts)}"
+
+    # 2. Exécuter la fusion (Appel à la fonction de stockage - placeholder)
+    merge_message = f"Merge branch '{pr['source_branch']}' into '{pr['target_branch']}' (PR #{pr_id})"
+    success_merge, merge_msg = execute_merge_commit(
+        repo_slug,
+        user_id,
+        pr['source_branch'],
+        pr['target_branch'],
+        merge_message,
+        committer_id # L'utilisateur qui exécute la fusion
+    )
+
+    if not success_merge:
+        return False, f"Échec de la fusion Git: {merge_msg}"
+
+    # 3. Mettre à jour le statut de la PR
+    return update_pull_request_status(pr_id, repo_slug, user_id, "Merged")
+
+
+def create_new_pr_branch(
+    user_id: str,
+    repo_slug: str,
+    new_branch_name: str
+) -> tuple[bool, str]:
+    """
+    Crée une nouvelle branche de PR en copiant le contenu du dépôt principal
+    vers le dépôt PRs sous un chemin isolé ({user_id}/{repo_slug}/{new_branch_name}).
+    """
+    if not new_branch_name:
+        return False, "Le nom de la nouvelle branche ne peut pas être vide."
+
+    # La branche est toujours créée à partir de 'main' dans ce contexte (target_branch)
+    # L'étape 1 est la copie des fichiers
+    # Appel à l'implémentation locale de 'copy_repo_to_new_branch_in_pr_repo'
+    success, message = copy_repo_to_new_branch_in_pr_repo(
+        user_id=user_id,
+        repo_slug=repo_slug,
+        new_branch_name=new_branch_name,
+        pr_repo_id=PULL_REQUESTS_HF_REPO_ID # Utilise la variable importée
+    )
+
+    if success:
+        return True, f"Branche de PR '{new_branch_name}' créée et initialisée avec les fichiers du dépôt principal."
+    else:
+        logger.error(f"Échec de la création de la branche de PR pour {repo_slug}/{new_branch_name}: {message}")
+        return False, f"Échec de la création de la branche : {message}"
+
+
+def get_files_in_pr_branch(pr_id: str, repo_slug: str, user_id: str) -> tuple[List[str], str]:
+    """
+    Récupère la liste de tous les fichiers dans la branche source (source_branch)
+    d'une Pull Request spécifique.
+    Fonction métier pour le Front-end.
+    """
+    pr = get_pull_request_by_id(pr_id, repo_slug, user_id)
+    if not pr:
+        return [], f"Pull Request ID {pr_id} introuvable."
+
+    branch_name = pr['source_branch']
+
+    # 1. Utilise la fonction locale de gestion de Hugging Face
+    file_list, error_msg = list_files_in_pr_branch(
+        user_id=user_id,
+        repo_slug=repo_slug,
+        branch_name=branch_name,
+        pr_repo_id=PULL_REQUESTS_HF_REPO_ID # La constante importée de config
+    )
+
+    # 2. Ajoute une couche de gestion des erreurs si le manager retourne un message
+    if error_msg:
+         # On logge une erreur (c'est déjà fait dans le manager, mais on peut ici retourner un message
+         # plus général au Front-end si nécessaire. On retourne ici le message d'erreur du manager)
+         return [], error_msg
+
+    # 3. Retourne la liste des fichiers et un message vide
+    return file_list, ""
+
+
+# --- CORRECTION D'INDENTATION : Cette fonction n'est plus imbriquée ---
+def get_pr_file_content(pr_id: str, repo_slug: str, user_id: str, file_path: str) -> tuple[Optional[str], str]:
+    """
+    Récupère le contenu d'un fichier spécifique à partir de la branche source de la PR.
+    """
+    pr = get_pull_request_by_id(pr_id, repo_slug, user_id)
+    if not pr:
+        return None, f"Pull Request ID {pr_id} introuvable."
+
+    branch_name = pr['source_branch']
+
+    # Appel à la fonction locale
+    return get_file_content_from_pr_branch(
+        user_id=user_id,
+        repo_slug=repo_slug,
+        branch_name=branch_name,
+        file_path=file_path,
+        pr_repo_id=PULL_REQUESTS_HF_REPO_ID
+    )
+
+# =========================================================================
+# === NOUVELLES FONCTIONS DE GESTION DE BRANCHE (Autonomisation du Fichier)
+# =========================================================================
+
+# Le routeur backend devra appeler cette fonction lorsque
+def copy_repo_to_new_branch_in_pr_repo(
+    user_id: str,
+    repo_slug: str,
+    new_branch_name: str,
+    pr_repo_id: Optional[str] = None # PULL_REQUESTS_HF_REPO_ID
+) -> tuple[bool, str]:
+    """
+    Copie récursivement tous les fichiers et dossiers d'un dépôt utilisateur/slug
+    vers un nouveau chemin dans le dépôt des Pull Requests.
+
+    Le chemin source est : HF_DATASET_REPO_ID / {user_id}/{repo_slug}
+    Le chemin cible est : PR_REPO_ID / {user_id}/{repo_slug}/{new_branch_name}
+    """
+    source_repo_id = HF_DATASET_REPO_ID
+    target_repo_id = pr_repo_id if pr_repo_id else PULL_REQUESTS_HF_REPO_ID
+
+    if not source_repo_id or not target_repo_id:
+        return False, "Erreur de configuration: Repository source ou cible Hugging Face non défini."
+
+    source_path_in_repo = f"{user_id}/{repo_slug}"
+    target_base_path = f"{source_path_in_repo}/{new_branch_name}"
+
+    # 1. Lister les fichiers dans le dépôt source
+    source_hf_path = f"datasets/{source_repo_id}/{source_path_in_repo}"
+
+    try:
+        # Utiliser HfFileSystem pour lister récursivement le contenu
+        # NOTE: Le chemin d'accès HfFileSystem nécessite le format 'hf://datasets/{repo_id}/...'
+        full_source_hf_path = f"hf://datasets/{source_repo_id}/{source_path_in_repo}"
+
+        all_items = fs.ls(full_source_hf_path, detail=True, recursive=True)
+
+        files_to_copy = [
+            item for item in all_items
+            if item.get('type') == 'file'
+        ]
+
+        if not files_to_copy:
+            return True, f"Aucun fichier trouvé à copier pour le dépôt '{repo_slug}'. La branche '{new_branch_name}' a été créée vide."
+
+        # Préparer les données pour le commit (liste d'opérations)
+        operations = []
+
+        for file_item in files_to_copy:
+            # item['name'] est le chemin complet HF. On a besoin du chemin RELATIF
+            # On retire le préfixe 'datasets/{repo_id}/' pour obtenir le chemin dans le dépôt
+            # Ex: 'datasets/repo_id/user_id/repo_slug/index.html' -> 'user_id/repo_slug/index.html'
+
+            # Pour un item listé par fs.ls(full_source_hf_path), 'name' est le chemin complet
+            # depuis la racine du repo hf://datasets/{source_repo_id}/
+            # Le chemin à enlever est 'hf://datasets/{source_repo_id}/'
+            prefix_to_remove = f"hf://datasets/{source_repo_id}/"
+            path_in_source_repo = file_item['name'].replace(prefix_to_remove, "", 1)
+            
+            # Le chemin RELATIF à la base de la source est :
+            # path_in_source_repo est 'user_id/repo_slug/index.html'. On veut 'index.html'
+            relative_path_from_base = path_in_source_repo.split(source_path_in_repo)[-1].lstrip('/')
+
+            # Nouveau chemin cible dans le repo de PRs : {user_id}/{repo_slug}/{new_branch_name}/{index.html}
+            target_file_path = f"{target_base_path}/{relative_path_from_base}"
+
+            # Récupérer le contenu brut du fichier
+            try:
+                # Utiliser fs.open avec le chemin 'name' retourné par fs.ls
+                with fs.open(file_item['name'], "rb") as f:
+                    file_content_bytes = f.read()
+
+                # Créer une opération d'ajout de fichier
+                operations.append(
+                    CommitOperationAdd(
+                        path_in_repo=target_file_path,
+                        path_or_fileobj=BytesIO(file_content_bytes) # Le contenu doit être un objet File-like (BytesIO)
+                    )
+                )
+
+            except Exception as e:
+                logger.error(f"Erreur lors de la lecture du fichier source {file_item['name']}: {e}")
+                # Continuer avec les autres fichiers
+                continue
+
+        # 2. Téléversement de tous les fichiers copiés en un seul commit atomique
+        commit_message = f"feat: Création de la branche '{new_branch_name}' à partir de main pour PR."
+
+        # Utiliser create_commit pour une opération atomique avec plusieurs ajouts
+        api.create_commit(
+            repo_id=target_repo_id,
+            operations=operations, # Utilisation de la liste des opérations
+            repo_type="dataset",
+            commit_message=commit_message,
+        )
+
+        message = f"Copie réussie de {len(files_to_copy)} fichiers vers la nouvelle branche '{new_branch_name}' dans le dépôt de PRs."
+        logger.info(message)
+        return True, message
+
+    except HfHubHTTPError as e:
+        logger.error(f"Erreur API Hugging Face lors de la copie pour {repo_slug}: {e}")
+        # Extrait la première ligne de la réponse d'erreur HTTP pour un message plus concis
+        error_detail = e.response.text.splitlines()[0] if e.response and e.response.text else str(e)
+        return False, f"Échec de la copie Hugging Face : {error_detail}"
+    except Exception as e:
+        logger.error(f"Erreur inconnue lors de la copie pour {repo_slug}: {e}")
+        return False, f"Erreur interne lors de la copie : {str(e)}"
+
+def list_files_in_pr_branch(
+    user_id: str,
+    repo_slug: str,
+    branch_name: str,
+    pr_repo_id: str # Le ID du dépôt de PRs (PULL_REQUESTS_HF_REPO_ID)
+) -> tuple[List[str], str]:
+    """
+    Liste tous les chemins de fichiers (relatifs à la racine de la branche)
+    dans le dossier isolé qui représente une branche de Pull Request.
+
+    Retourne (liste_des_fichiers, message_d_erreur).
+    """
+    if not pr_repo_id:
+        return [], "Erreur de configuration: PULL_REQUESTS_HF_REPO_ID est manquant."
+
+    # Le chemin dans le repo de PRs est toujours "{user_id}/{repo_slug}/{branch_name}"
+    # Le préfixe "pr_data/" est ajouté par convention dans le fichier prs.json, mais
+    # le chemin dans le dépôt des PRs semble être "pr_data/{user_id}/{repo_slug}/{branch_name}"
+    # selon la fonction list_files_in_pr_branch (dans l'ancien manager)
+    branch_folder_path_in_repo = f"pr_data/{user_id}/{repo_slug}/{branch_name}"
+
+    try:
+        # Construit le chemin complet de l'API HfFileSystem
+        repo_fs_path = f"hf://datasets/{pr_repo_id}/{branch_folder_path_in_repo}"
+
+        # Liste récursivement tous les éléments dans le dossier de la branche
+        files_info = fs.ls(repo_fs_path, detail=True, recursive=True)
+
+        file_paths = []
+        for file_item in files_info:
+            if file_item.get('type') == 'file':
+                # Le 'name' de l'item est le chemin complet
+                prefix = f"hf://datasets/{pr_repo_id}/{branch_folder_path_in_repo}/"
+
+                # On veut le chemin relatif à la racine de la branche.
+                relative_path = file_item['name'].replace(prefix, "", 1)
+
+                # S'assurer qu'il ne s'agit pas d'un fichier de métadonnées interne si vous en utilisez
+                if relative_path and relative_path != "metadata.json":
+                    file_paths.append(relative_path)
+
+        return file_paths, ""
+
+    except FileNotFoundError:
+        message = f"Dossier de branche PR '{branch_name}' non trouvé dans le dépôt de PRs."
+        logger.warning(message)
+        return [], message
+    except HfHubHTTPError as e:
+        message = f"Erreur API Hugging Face lors de la liste des fichiers pour la branche {branch_name}: {e}"
+        logger.error(message)
+        return [], message
+    except Exception as e:
+        message = f"Erreur inconnue lors de la liste des fichiers pour la branche {branch_name}: {e}"
+        logger.error(message)
+        return [], message
+
+def get_file_content_from_pr_branch(
+    user_id: str,
+    repo_slug: str,
+    branch_name: str,
+    file_path: str, # Le chemin relatif du fichier (ex: index.html)
+    pr_repo_id: str
+) -> tuple[Optional[str], str]:
+    """
+    Récupère le contenu brut d'un fichier spécifique dans la branche isolée de la PR.
+    Retourne (contenu_du_fichier, message_d_erreur).
+    """
+    if not pr_repo_id:
+        return None, "Erreur de configuration: PULL_REQUESTS_HF_REPO_ID manquant."
+
+    # Construit le chemin complet du fichier dans le dépôt de PRs
+    # pr_data/{user_id}/{repo_slug}/{branch_name}/{file_path}
+    full_path_in_repo = f"pr_data/{user_id}/{repo_slug}/{branch_name}/{file_path}"
+
+    try:
+        # Chemin HfFileSystem
+        repo_fs_path = f"hf://datasets/{pr_repo_id}/{full_path_in_repo}"
+
+        # Lecture du contenu du fichier en bytes
+        file_bytes = fs.read_bytes(repo_fs_path)
+
+        # Tentative de décodage en UTF-8 pour le contenu texte
+        try:
+            content = file_bytes.decode('utf-8')
+            return content, ""
+        except UnicodeDecodeError:
+            return None, f"Le fichier '{file_path}' n'est pas un fichier texte standard (UTF-8). Contenu binaire non supporté pour l'édition."
+
+    except FileNotFoundError:
+        message = f"Fichier '{file_path}' non trouvé dans la branche PR '{branch_name}'."
+        logger.warning(message)
+        return None, message
+    except HfHubHTTPError as e:
+        message = f"Erreur API Hugging Face lors de la lecture du fichier pour la branche {branch_name}: {e}"
+        logger.error(message)
+        return None, message
+    except Exception as e:
+        message = f"Erreur inconnue lors de la lecture du fichier: {e}"
+        logger.error(message)
+        return None, message
+
+def get_repo_branches(repo_slug: str, user_id: str) -> tuple[List[str], str]:
+    """
+    Récupère la liste de toutes les branches (Pull Requests ouvertes) 
+    pour un dépôt utilisateur spécifique (user_id/repo_slug).
+
+    Dans le contexte Hugging Face, cela liste les branches créées par la 
+    fonction `create_pull_request` dans le dépôt de PRs.
+    
+    Retourne (liste_des_noms_de_branches, message_d_erreur).
+    """
+    # Dans votre architecture, la branche principale du dépôt est le 'repo_slug' lui-même.
+    # Les branches de PRs sont des sous-dossiers dans le dépôt de PRs.
+    
+    # 1. Obtenir la liste des Pull Requests ouvertes (qui sont les branches de travail)
+    try:
+        # La branche par défaut (le dépôt "main") est le repo_slug
+        branches = [repo_slug]
+        
+        # Charger la liste des PRs ouvertes (chaque PR correspond à une 'source_branch')
+        pr_list = load_all_prs_from_hf(repo_slug, user_id)
+        
+        for pr in pr_list:
+            # Nous ajoutons toutes les 'source_branch' qui sont actuellement ouvertes
+            if pr['status'] == 'Open' and pr['source_branch'] not in branches:
+                branches.append(pr['source_branch'])
+                
+        # Dans un système Git standard, on utiliserait api.list_repo_branches(repo_id).
+        # Ici, l'approche doit être hybride (Target Branch + Source Branches ouvertes).
+        
+        return branches, ""
+    
+    except Exception as e:
+        message = f"Erreur lors de la récupération des branches pour {repo_slug}: {e}"
+        logger.error(message)
+        return [repo_slug], message # Retourne au moins la branche par défaut en cas d'erreur

a6ea61c8-951a-413a-ba9d-7365d83fbd4d/mayproject/repo_settings_manager.py

@@ -0,0 +1,191 @@
+# repo_settings_manager.py
+import logging
+from typing import Optional, Dict, List, Tuple
+
+# Importation des fonctions nécessaires de huggingface_repo_manager
+# Assurez-vous que huggingface_repo_manager.py est dans le même dossier ou accessible dans le PYTHONPATH
+from huggingface_repo_manager import (
+    get_user_repo_metadata,
+    update_user_repo_metadata,
+    load_json_file_from_hf,
+    save_json_file_to_hf,
+)
+
+# Assurez-vous d'importer la variable de configuration si nécessaire
+try:
+    from config import HF_DATASET_REPO_ID
+except ImportError:
+    # Solution de repli, à adapter si config.py est essentiel
+    import os
+    HF_DATASET_REPO_ID = os.environ.get("HF_DATASET_REPO_ID")
+
+logger = logging.getLogger(__name__)
+
+# --- Constantes de configuration ---
+SECRETS_FILE_NAME = "secrets.json"
+VARIABLES_FILE_NAME = "variables.json"
+
+def _get_config_file_path(repo_slug: str, config_type: str) -> str:
+    """Détermine le chemin du fichier JSON de configuration (secrets ou variables) 
+    dans le chemin de l'utilisateur."""
+    if config_type == 'secrets':
+        file_name = SECRETS_FILE_NAME
+    elif config_type == 'variables':
+        file_name = VARIABLES_FILE_NAME
+    else:
+        raise ValueError(f"Type de configuration non supporté: {config_type}")
+    
+    # Le chemin dans le repo de l'utilisateur est : repo_slug/secrets.json ou repo_slug/variables.json
+    return f"{repo_slug}/{file_name}"
+
+# NOUVELLE FONCTION : Lecture des paramètres du dépôt (Nom, Description, Visibilité)
+def get_repo_settings(user_id: str, repo_slug: str) -> Tuple[Optional[Dict], str]:
+    """
+    Charge le nom, la description, et la visibilité d'un dépôt spécifique 
+    à partir du fichier metadata.json de l'utilisateur.
+    """
+    
+    metadata, message = get_user_repo_metadata(user_id)
+    if metadata is None:
+        return None, f"Échec de la lecture des métadonnées utilisateur: {message}"
+
+    for repo in metadata.get("repos", []):
+        if repo.get('FIELD_DEPLOY_ID') == repo_slug: 
+            return repo, "Paramètres du dépôt chargés avec succès."
+
+    return None, f"Dépôt '{repo_slug}' non trouvé dans les métadonnées de l'utilisateur."
+
+# NOUVELLE FONCTION : Mise à jour des paramètres du dépôt (Nom, Description, Visibilité)
+def update_repo_settings(user_id: str, repo_slug: str, new_data: Dict) -> Tuple[bool, str]:
+    """
+    Met à jour le nom, la description, et la visibilité du dépôt dans metadata.json
+    en utilisant la fonction update_user_repo_metadata.
+    """
+    
+    # 1. Charger les métadonnées actuelles
+    current_metadata, message = get_user_repo_metadata(user_id)
+    if current_metadata is None:
+        logger.error(f"Impossible de charger les métadonnées pour {user_id}: {message}")
+        return False, f"Impossible de charger les métadonnées pour la mise à jour: {message}"
+
+    # 2. Trouver et mettre à jour l'entrée du dépôt
+    repos = current_metadata.get("repos", [])
+    repo_to_update = None
+    
+    for repo in repos:
+        if repo.get('FIELD_DEPLOY_ID') == repo_slug: 
+            repo_to_update = repo
+            break
+    
+    if repo_to_update is None:
+        return False, f"Dépôt '{repo_slug}' non trouvé dans les métadonnées de l'utilisateur."
+
+    # Mettre à jour les données du dépôt
+    # On met à jour uniquement les clés fournies dans new_data 
+    repo_to_update.update(new_data)
+    
+    # 3. Sauvegarder le fichier de métadonnées mis à jour
+    # update_user_repo_metadata gère la logique de remplacement/mise à jour
+    success, message = update_user_repo_metadata(
+        user_id=user_id,
+        new_repo_data=repo_to_update, 
+        repo_id=HF_DATASET_REPO_ID
+    )
+
+    if success:
+        logger.info(f"Paramètres du dépôt '{repo_slug}' mis à jour par l'utilisateur {user_id}.")
+        return True, "Paramètres du dépôt mis à jour avec succès."
+    else:
+        logger.error(f"Échec de la sauvegarde des métadonnées pour {user_id}/{repo_slug}: {message}")
+        return False, f"Échec de la mise à jour des paramètres du dépôt: {message}"
+
+# NOUVELLE FONCTION : Lire la configuration complète (Secrets ou Variables)
+def get_repo_config(user_id: str, repo_slug: str, config_type: str) -> Tuple[Optional[Dict], str]:
+    """
+    Charge la configuration complète (secrets ou variables) d'un dépôt 
+    à partir du fichier JSON correspondant (secrets.json ou variables.json).
+    """
+    
+    try:
+        # Construit le chemin du fichier JSON relatif au HF_DATASET_REPO_ID
+        file_path_in_repo = _get_config_file_path(repo_slug, config_type)
+    except ValueError as e:
+        return None, str(e)
+        
+    # Le chemin complet pour les fonctions HF est user_id/repo_slug/config_file.json
+    full_path = f"{user_id}/{file_path_in_repo}"
+    
+    current_config, message = load_json_file_from_hf(full_path, repo_id=HF_DATASET_REPO_ID)
+    
+    if current_config is None:
+        # Si le fichier n'existe pas, on retourne une liste vide, ce qui est normal
+        if "non trouvé" in message.lower():
+            # Initialise avec une structure standard
+            return {"entries": []}, "Configuration chargée (fichier non existant, retourné vide)."
+        else:
+            return None, f"Échec du chargement de la configuration: {message}"
+    
+    return current_config, "Configuration chargée avec succès."
+
+
+# NOUVELLE FONCTION : Gérer l'ajout/modification/suppression d'une entrée (Secret ou Variable)
+def manage_repo_config_entry(
+    user_id: str,
+    repo_slug: str,
+    config_type: str, # 'secrets' ou 'variables'
+    operation: str, # 'add', 'update', 'delete'
+    entry_name: str,
+    entry_data: Optional[Dict] = None # Contient 'name', 'description', 'value'
+) -> Tuple[bool, str]:
+    """
+    Ajoute, met à jour ou supprime une entrée de configuration (secret ou variable)
+    dans le fichier JSON correspondant et le sauvegarde sur Hugging Face.
+    """
+    
+    if operation not in ['add', 'update', 'delete']:
+        return False, "Opération non reconnue."
+    
+    # Validation des données pour add/update
+    if operation != 'delete' and (not entry_data or 'name' not in entry_data):
+        return False, "Les données d'entrée ou le nom de l'entrée sont manquants pour l'opération."
+
+    try:
+        file_path_in_repo = _get_config_file_path(repo_slug, config_type)
+    except ValueError as e:
+        return False, str(e)
+        
+    full_path = f"{user_id}/{file_path_in_repo}"
+
+    # 1. Charger la configuration actuelle (ou initialiser si manquante)
+    current_config, _ = load_json_file_from_hf(full_path, repo_id=HF_DATASET_REPO_ID)
+    if current_config is None or "non trouvé" in _:
+        current_config = {"entries": []}
+    
+    entries = current_config.get("entries", [])
+    
+    # 2. Mettre à jour la liste
+    # Retirer l'ancienne entrée si elle existe (par le nom)
+    # Ceci gère la suppression et prépare l'ajout/mise à jour
+    entries = [e for e in entries if e.get('name') != entry_name]
+    
+    if operation == 'add' or operation == 'update':
+        entries.append(entry_data)
+
+    current_config["entries"] = entries
+    
+    # 3. Sauvegarder le fichier JSON mis à jour
+    commit_msg = f"{operation.capitalize()} {config_type} '{entry_name}' pour le dépôt {repo_slug}."
+    
+    success, message = save_json_file_to_hf(
+        file_path=full_path,
+        data=current_config,
+        commit_message=commit_msg,
+        repo_id=HF_DATASET_REPO_ID 
+    )
+    
+    if success:
+        logger.info(f"Opération '{operation}' sur {config_type} '{entry_name}' réussie pour {repo_slug}.")
+        return True, message
+    else:
+        logger.error(f"Échec de l'opération '{operation}' sur {config_type} pour {repo_slug}: {message}")
+        return False, message

a6ea61c8-951a-413a-ba9d-7365d83fbd4d/mayproject/repo_settings_routes.py

@@ -0,0 +1,116 @@
+# repo_settings_routes.py
+from flask import Blueprint, request, jsonify, abort
+from typing import Dict
+
+settings_bp = Blueprint('settings', __name__, url_prefix='/api/settings')
+# Assurez-vous que repo_settings_manager.py est accessible
+from repo_settings_manager import (
+    get_repo_settings,
+    update_repo_settings,
+    get_repo_config,
+    manage_repo_config_entry
+)
+
+
+
+# --- Routes pour les Paramètres Généraux du Dépôt (Nom, Description, Visibilité) ---
+
+# Route 1: Lire les paramètres du dépôt
+@settings_bp.route('/<user_id>/repo/<repo_slug>', methods=['GET'])
+def get_repo_settings_route(user_id, repo_slug):
+    """
+    Récupère le nom, la description, et la visibilité d'un dépôt.
+    GET /api/settings/<user_id>/repo/<repo_slug>
+    """
+    settings, message = get_repo_settings(user_id, repo_slug)
+    
+    if settings is None:
+        # Retourne 404 si le dépôt n'est pas trouvé
+        return jsonify({"success": False, "message": message}), 404
+        
+    return jsonify({"success": True, "data": settings}), 200
+
+# Route 2: Mettre à jour les paramètres du dépôt (Nom, Description, Visibilité)
+@settings_bp.route('/<user_id>/repo/<repo_slug>', methods=['PUT'])
+def update_repo_settings_route(user_id, repo_slug):
+    """
+    Met à jour les paramètres d'un dépôt (name, description, visibility).
+    PUT /api/settings/<user_id>/repo/<repo_slug>
+    Corps: {'name': 'nouveau_nom', 'description': 'nouvelle_desc', 'visibility': 'public'}
+    """
+    data: Dict = request.json
+    
+    if not data:
+        return jsonify({"success": False, "message": "Aucune donnée fournie."}), 400
+        
+    success, message = update_repo_settings(user_id, repo_slug, data)
+    
+    if not success:
+        return jsonify({"success": False, "message": message}), 500
+        
+    return jsonify({"success": True, "message": message}), 200
+
+
+# --- Routes pour la Configuration (Secrets et Variables) ---
+
+# Route 3: Lire la configuration complète (Secrets ou Variables)
+@settings_bp.route('/<user_id>/repo/<repo_slug>/config/<config_type>', methods=['GET'])
+def get_repo_config_route(user_id, repo_slug, config_type):
+    """
+    Récupère la liste complète des secrets ou des variables.
+    GET /api/settings/<user_id>/repo/<repo_slug>/config/secrets
+    """
+    if config_type not in ['secrets', 'variables']:
+        return jsonify({"success": False, "message": "Type de configuration invalide. Utilisez 'secrets' ou 'variables'."}), 400
+
+    config_data, message = get_repo_config(user_id, repo_slug, config_type)
+    
+    if config_data is None:
+        return jsonify({"success": False, "message": message}), 500
+        
+    # config_data contiendra {"entries": []} si le fichier n'existe pas, ce qui est correct.
+    return jsonify({"success": True, "data": config_data}), 200
+
+
+# Route 4: Gérer les Secrets/Variables (Ajout/Modification/Suppression d'une entrée)
+@settings_bp.route('/<user_id>/repo/<repo_slug>/config/<config_type>', methods=['POST'])
+def manage_repo_config_route(user_id, repo_slug, config_type):
+    """
+    Ajoute, met à jour ou supprime un secret/variable spécifique.
+    POST /api/settings/<user_id>/repo/<repo_slug>/config/secrets
+    Corps: {'operation': 'add'/'update'/'delete', 'name': 'NOM_CLE', 'entry_data': {...}}
+    """
+    data: Dict = request.json
+    
+    if config_type not in ['secrets', 'variables']:
+        return jsonify({"success": False, "message": "Type de configuration invalide. Utilisez 'secrets' ou 'variables'."}), 400
+    
+    entry_name = data.get('name')
+    operation = data.get('operation') # 'add', 'update', 'delete'
+    entry_data = data.get('entry_data') # Contient 'name', 'description', 'value'
+    
+    # Validation minimale
+    if not entry_name or not operation:
+        return jsonify({"success": False, "message": "Données manquantes ('name' ou 'operation')."}), 400
+    
+    if operation != 'delete' and not entry_data:
+        return jsonify({"success": False, "message": f"Données d'entrée ('entry_data') manquantes pour l'opération '{operation}'."}), 400
+        
+    # L'entrée 'name' dans entry_data doit correspondre à entry_name pour la cohérence
+    if entry_data and entry_data.get('name') != entry_name:
+        return jsonify({"success": False, "message": "Incohérence: 'name' dans entry_data doit correspondre à 'name' au niveau supérieur."}), 400
+
+
+    success, message = manage_repo_config_entry(
+        user_id=user_id,
+        repo_slug=repo_slug,
+        config_type=config_type,
+        operation=operation,
+        entry_name=entry_name,
+        entry_data=entry_data # Sera None pour 'delete'
+    )
+    
+    if not success:
+        return jsonify({"success": False, "message": message}), 500
+        
+    return jsonify({"success": True, "message": message}), 200

a6ea61c8-951a-413a-ba9d-7365d83fbd4d/mayproject/requirements.txt

@@ -0,0 +1,13 @@
+flask
+bcrypt
+requests
+gunicorn
+Flask-CORS
+python-dotenv
+stripe
+dnspython
+werkzeug
+flask-socketio
+eventlet
+huggingface_hub
+google-genai

a6ea61c8-951a-413a-ba9d-7365d83fbd4d/mayproject/user_routes.py

@@ -0,0 +1,453 @@
+# user_routes.py (Version SSR - Rendu Côté Serveur)
+
+from datetime import datetime # <-- AJOUTER CECI
+import logging # <-- NOUVEL IMPORT
+from flask import Blueprint, request, jsonify, session, redirect, url_for, flash, render_template
+import uuid
+from decorators import login_required
+from auth_backend import (
+    register_user,
+    login_user,
+    reset_password_via_security_question,
+    get_user_by_id,
+    update_user_profile,
+    # Assurez-vous d'importer toute autre fonction nécessaire ici (ex: is_email_unique)
+)
+
+from decorators import api_session_required 
+from huggingface_repo_manager import (
+    create_empty_repo_folder_on_hf,
+    update_user_repo_metadata,
+    get_user_repo_metadata, 
+    upload_files_to_repo_backend, 
+    # NOUVEAUX IMPORTS
+    list_repo_files_from_hf, # <-- DÉJÀ EXISTANT DANS LE FICHIER FOURNI
+    get_file_content_from_hf, # <-- NOUVELLE FONCTION AJOUTÉE
+)
+logger = logging.getLogger(__name__) # <-- AJOUTER CETTE LIGNE
+# Création du Blueprint 'user_bp' 
+user_bp = Blueprint('user_bp', __name__)
+
+# ----------------------------------------------------------------------
+# ENDPOINTS PAGES SÉCURISÉES (Rendu Côté Serveur)
+# Les pages sensibles sont protégées par @login_required.
+# ----------------------------------------------------------------------
+
+# Liste des pages sensibles à protéger.
+SECURE_PAGES = [
+    # "dashboard.html", # <--- RETIRÉ car géré par la route spécifique dashboard()
+    # "profile.html",   # <--- RETIRÉ car géré par la route spécifique profile()
+    # "nouveau_project.html",  # <--- RETIRÉ car géré par la route spécifique profile()
+    "html_launcher.html",
+    "create_new_file.html",
+    "checkout.html",
+    # Ajoutez toutes les autres pages sensibles ici
+]
+
+def create_secure_page_route(page_name):
+    """
+    Fonction d'usine pour créer dynamiquement une fonction de vue unique 
+    et garantir un nom d'endpoint unique pour chaque page sécurisée.
+    """
+    
+    # Création d'un nom d'endpoint unique (ex: secure_page_nouveau_project_html)
+    endpoint_name = f"secure_page_{page_name.replace('.', '_')}"
+
+    @login_required
+    def secure_page_view():
+        # La variable 'page_name' est correctement capturée dans la closure
+        # Rendu simple de tous les templates sécurisés
+        return render_template(page_name)
+
+    # --- MODIFICATION ICI : On retire l'extension .html du chemin de la route ---
+    route_path_without_ext = page_name.replace('.html', '')
+    
+    # Enregistrement de la règle d'URL avec le nom d'endpoint unique
+    user_bp.add_url_rule(
+        f"/mindus/nexus/{route_path_without_ext}", # <-- NOUVEAU CHEMIN SANS EXTENSION
+        endpoint=endpoint_name,
+        view_func=secure_page_view,
+        methods=['GET'] # Par défaut, ces routes sont généralement GET
+    )
+
+# Création dynamique des routes sécurisées
+for page in SECURE_PAGES:
+    create_secure_page_route(page)
+
+
+# Route spécifique pour le Profil car elle gère aussi un formulaire POST
+@user_bp.route("/mindus/nexus/profile", methods=['GET', 'POST'])
+@login_required
+def profile():
+    """
+    Page de profil. Gère la mise à jour via POST et sert la page via GET (SSR).
+    """
+    user_id = session.get('user_id')
+    
+    if request.method == 'POST':
+        # 1. Récupération des données du formulaire POST
+        username = request.form.get('username')
+        email = request.form.get('email')
+        new_password = request.form.get('new_password')
+        confirm_password = request.form.get('confirm_password')
+
+        # 2. Validation et mise à jour
+        if not username or not email:
+            flash("Le nom d'utilisateur et l'e-mail sont obligatoires.", "error")
+        elif new_password and new_password != confirm_password:
+            flash("Le nouveau mot de passe et la confirmation ne correspondent pas.", "error")
+        else:
+            password_to_update = new_password if new_password and new_password == confirm_password else None
+            
+            success, message = update_user_profile(user_id, username, email, password_to_update)
+            
+            if success:
+                flash(message, "success")
+                return redirect(url_for('user_bp.profile'))  # Redirection POST/Redirect/GET
+            else:
+                flash(message, "error")
+
+    # Logique pour la méthode GET ou après un échec POST
+    # On passe l'objet utilisateur si nécessaire pour pré-remplir le formulaire
+    # NOTE: Une alternative est d'utiliser l'API GET /api/profile côté JS dans le template
+    user_data = get_user_by_id(user_id) # Récupérer les données utilisateur pour le template
+    
+    return render_template('profile.html', user=user_data)
+
+
+@user_bp.route("/mindus/nexus/dashboard")
+@login_required
+def dashboard():
+    """
+    Page du tableau de bord. Gère le message de succès de paiement (Phase 4).
+    """
+    payment_status = request.args.get('payment')
+    
+    # Si succès de paiement, flasher et rediriger pour nettoyer l'URL
+    if payment_status == 'success':
+        flash("Félicitations ! Votre abonnement a été activé avec succès.", "success")
+        # Utiliser la route sans argument pour nettoyer l'URL
+        # NOTE: url_for('user_bp.dashboard') pointe vers la fonction actuelle
+        return redirect(url_for('user_bp.dashboard'))
+        
+    return render_template('dashboard.html')
+
+
+# ----------------------------------------------------------------------
+# ENDPOINTS D'AUTHENTIFICATION (API JSON) - CONSERVÉS
+# ----------------------------------------------------------------------
+# Ces routes restent des APIs JSON
+# ATTENTION: Il faut ajouter 'api_session_required' au profil API POST/GET comme dans l'original.
+
+@user_bp.route("/api/register", methods=['POST'])
+def register_user_api():
+    """Endpoint API pour l'inscription. Attend JSON, retourne JSON."""
+    data = request.get_json()
+
+    if not data:
+        return jsonify({"success": False, "message": "Données JSON manquantes."}), 400
+
+    username = data.get("username")
+    email = data.get("email")
+    password = data.get("password")
+    confirm_password = data.get("confirm_password")
+    security_question = data.get("security_question")
+    security_answer = data.get("security_answer")
+
+    # Logique d'inscription
+    user_id, message, _ = register_user(username, email, password, confirm_password, security_question, security_answer)
+
+    if user_id:
+        # Rediriger vers la page de connexion (web_bp.connexion_page)
+        return jsonify({"success": True, "message": message, "redirect": url_for('web_bp.connexion_page')})
+    else:
+        return jsonify({"success": False, "message": message}), 400
+
+
+@user_bp.route("/api/login", methods=['POST'])
+def login_user_api():
+    """Endpoint API pour la connexion. Attend JSON, retourne JSON."""
+    data = request.get_json()
+
+    if not data:
+        return jsonify({"success": False, "message": "Données JSON manquantes."}), 400
+
+    email = data.get("email")
+    password = data.get("password")
+    
+    # Logique de connexion
+    user_id, message, user_data = login_user(email, password)
+
+    if user_id:
+        session['user_id'] = user_id
+        # Redirige vers la nouvelle route du dashboard sécurisé
+        # NOTE: Utilisation du nom de la fonction 'dashboard' qui est l'endpoint de cette route.
+        return jsonify({"success": True, "message": message, "redirect": url_for('user_bp.dashboard')})
+    else:
+        return jsonify({"success": False, "message": message}), 401
+
+
+@user_bp.route("/api/logout", methods=['POST'])
+def logout_user_api():
+    """Endpoint API pour la déconnexion. Détruit la session."""
+    session.pop('user_id', None)
+    # Redirige vers la page de connexion
+    return jsonify({"success": True, "message": "Déconnexion réussie.", "redirect": url_for('web_bp.connexion_page')})
+
+
+@user_bp.route("/api/profile", methods=['GET'])
+@api_session_required # <--- AJOUT DU DÉCORATEUR
+def get_profile_api(client_user): # <--- Accepte l'objet injecté
+    """Endpoint API pour récupérer les informations du profil de l'utilisateur connecté."""
+    # Les données de l'utilisateur sont déjà récupérées par api_session_required
+    user = client_user
+    
+    # On ne retourne pas le hash du mot de passe ou la réponse de sécurité
+    user_info = {
+        'username': user.get('username'),
+        'email': user.get('email'),
+        'plan': user.get('current_plan'),
+        'joined_at': user.get('join_date'),
+    }
+    return jsonify({"success": True, "user": user_info})
+
+
+@user_bp.route("/api/profile", methods=['POST'])
+@api_session_required # <--- AJOUT DU DÉCORATEUR
+def update_profile_api(client_user): # <--- Accepte l'objet injecté
+    """Endpoint API pour la mise à jour du profil (username, email, password)."""
+    user_id = client_user['uuid'] # Utilise l'ID de l'objet utilisateur
+    data = request.get_json()
+
+    if not data:
+        return jsonify({"success": False, "message": "Données JSON manquantes."}), 400
+
+    username = data.get("username")
+    email = data.get("email")
+    new_password = data.get("new_password")
+    confirm_password = data.get("confirm_password")
+
+    password_to_update = None
+    message_password_error = ""
+
+    # 1. Validation du mot de passe s'il est fourni
+    if new_password or confirm_password:
+        if new_password != confirm_password:
+            message_password_error = "Le nouveau mot de passe et la confirmation ne correspondent pas."
+        elif len(new_password) < 8:
+            message_password_error = "Le nouveau mot de passe est trop court (min 8 caractères)."
+        else:
+            password_to_update = new_password
+
+    if message_password_error:
+        return jsonify({"success": False, "message": message_password_error}), 400
+
+    # 2. Appel de la fonction de mise à jour du backend
+    success, message = update_user_profile(user_id, username, email, password_to_update)
+    
+    if success:
+        return jsonify({"success": True, "message": message})
+    else:
+        # Échec de la mise à jour (ex: email déjà pris)
+        return jsonify({"success": False, "message": message}), 400
+
+
+@user_bp.route("/mindus/nexus/editor", methods=['GET'])
+@login_required
+# MODIFICATION: Retire repo_slug de la signature de la fonction.
+def editor_page(): 
+    """
+    Page de l'éditeur de code.
+    Nécessite le repo_slug pour définir le contexte du dépôt Hugging Face.
+    """
+    user_id = session.get('user_id')
+    
+    # NOUVEAU: Récupère le repo_slug à partir des paramètres de requête (?repo_slug=...)
+    repo_slug = request.args.get('repo_slug')
+    
+    user_data = get_user_by_id(user_id) # On récupère les données utilisateur (nécessaire pour le template)
+    
+    # AJOUT DE VÉRIFICATION
+    if not repo_slug:
+        flash("Le slug du dépôt est manquant dans l'URL.", "error")
+        return redirect(url_for('user_bp.dashboard'))
+        
+    if not user_data:
+        flash("Utilisateur non trouvé.", "error")
+        return redirect(url_for('web_bp.connexion_page'))
+
+    # Vous pouvez ajouter ici une logique pour vérifier si le repo_slug 
+    # appartient bien à l'utilisateur, ou pour récupérer les métadonnées du dépôt.
+    
+    # Par exemple, pour l'afficher dans le template (même si vous ne l'utilisez pas directement maintenant)
+    context = {
+        'user': user_data,
+        'repo_slug': repo_slug, # Passage du slug au template
+        # Vous pourriez ajouter ici les données du dépôt récupérées via get_user_repo_metadata
+    }
+
+    return render_template('editor.html', **context)
+
+# MODIFICATION: Ajout du paramètre conversation_id (optionnel) dans l'URL
+@user_bp.route("/mindus/nexus/gitforge_copilot", methods=['GET'])
+@user_bp.route("/mindus/nexus/gitforge_copilot/<conversation_id>", methods=['GET']) # Nouvelle route dynamique
+@login_required
+def gemini_chat_page(conversation_id=None): # Le paramètre est maintenant accepté
+    """
+    Affiche la page de chat Gemini et passe l'ID de conversation (s'il existe) au template.
+    """
+    
+    context = {
+        # Passe None ou l'ID au template pour que le front-end sache quelle discussion charger
+        'conversation_id': conversation_id 
+    }
+    
+    # Assurez-vous que votre template peut utiliser 'conversation_id'
+    return render_template('gitforge_copilot.html', **context)
+
+
+# Route spécifique pour les paramètres de dépôt
+@user_bp.route("/mindus/nexus/settings", methods=['GET'])
+@login_required
+def settings_page():
+    """
+    Affiche la page des paramètres du dépôt.
+    Nécessite le repo_slug passé en paramètre de requête (?repo_slug=...).
+    """
+    user_id = session.get('user_id')
+    
+    # Récupère le repo_slug à partir des paramètres de requête (?repo_slug=...)
+    repo_slug = request.args.get('repo_slug')
+    
+    user_data = get_user_by_id(user_id) # On récupère les données utilisateur
+    
+    # AJOUT DE VÉRIFICATION
+    if not repo_slug:
+        flash("Le slug du dépôt est manquant dans l'URL. Impossible d'afficher les paramètres.", "error")
+        return redirect(url_for('user_bp.dashboard'))
+        
+    if not user_data:
+        flash("Utilisateur non trouvé.", "error")
+        return redirect(url_for('web_bp.connexion_page'))
+
+    # Le template settings.html doit utiliser 'repo_slug' pour construire ses appels API JS
+    context = {
+        'user': user_data,
+        'repo_slug': repo_slug, # Passage du slug au template
+    }
+
+    return render_template('settings.html', **context)
+
+# Route pour afficher la page de l'instance de déploiement (Logs/Events)
+@user_bp.route("/mindus/nexus/dynamic_and_static", methods=['GET'])
+@login_required
+def deployment_instance_page():
+    """
+    Affiche la page de l'instance de déploiement (logs, events, etc.).
+    Nécessite le repo_slug passé en paramètre de requête (?repo_slug=...).
+    Le template est 'dynamic_and_static.html'.
+    """
+    user_id = session.get('user_id')
+    
+    # 1. Récupère le repo_slug à partir des paramètres de requête (?repo_slug=...)
+    repo_slug = request.args.get('repo_slug')
+    
+    user_data = get_user_by_id(user_id) # Récupère les données utilisateur pour le template
+    
+    # 2. Vérification obligatoire du repo_slug
+    if not repo_slug:
+        flash("Le slug du dépôt est manquant dans l'URL. Impossible d'afficher l'instance.", "error")
+        return redirect(url_for('user_bp.dashboard'))
+        
+    if not user_data:
+        flash("Utilisateur non trouvé.", "error")
+        return redirect(url_for('web_bp.connexion_page'))
+
+    # 3. Préparation du contexte
+    context = {
+        'user': user_data,
+        'repo_slug': repo_slug, # Passage du slug au template (utilisé par le JS)
+        # Vous pouvez ajouter d'autres données ici si nécessaire pour le rendu SSR
+    }
+
+    # 4. Rendu du template
+    return render_template('dynamic_and_static.html', **context)
+
+
+@user_bp.route("/mindus/nexus/new_branch", methods=['GET'])
+@login_required
+def new_branch_page():
+    """
+    Affiche la page de création d'une nouvelle branche.
+    Nécessite le repo_slug passé en paramètre de requête (?repo_slug=...).
+    Le template est 'new_branch.html'.
+    """
+    user_id = session.get('user_id')
+    
+    # 1. Récupère le repo_slug à partir des paramètres de requête (?repo_slug=...)
+    repo_slug = request.args.get('repo_slug')
+    
+    user_data = get_user_by_id(user_id) # Récupère les données utilisateur
+    
+    # 2. Vérification obligatoire du repo_slug
+    if not repo_slug:
+        flash("Le slug du dépôt est manquant dans l'URL. Impossible de créer une nouvelle branche.", "error")
+        return redirect(url_for('user_bp.dashboard'))
+        
+    if not user_data:
+        flash("Utilisateur non trouvé.", "error")
+        return redirect(url_for('web_bp.connexion_page'))
+
+    # 3. Extraction du nom du dépôt (repo_name) à partir du repo_slug
+    # Ceci est utilisé par le templating Jinja2 dans le header: user / repo
+    repo_name = repo_slug.split('/')[-1]
+
+    # 4. Préparation du contexte
+    context = {
+        'user': user_data,        # Contient user.username pour le Jinja2
+        'repo_slug': repo_slug,   # Le slug complet (e.g., user/repo)
+        'repo_name': repo_name,   # Juste le nom du dépôt (e.g., repo)
+    }
+
+    # 5. Rendu du template
+    # Assurez-vous que le nom de votre fichier est bien 'new_branch.html'
+    return render_template('new_branch.html', **context)
+
+
+@user_bp.route("/mindus/nexus/repo_files_branch", methods=['GET'])
+@login_required
+def repo_files_page():
+    user_id = session.get('user_id')
+    
+    # 1. Récupère le repo_slug
+    repo_slug = request.args.get('repo_slug') 
+    
+    # 2. Récupère le nom de la branche sélectionnée
+    current_branch = request.args.get('branch', 'main') 
+
+    # *** AJOUT POUR LE DIAGNOSTIC (Cible) ***
+    logger.info(f"Navigation vers le dépôt: repo_slug='{repo_slug}', branch='{current_branch}' pour user_id={user_id}")
+    
+    # 3. Vérifications (repo_slug est obligatoire)
+    if not repo_slug:
+        flash("Le slug du dépôt est manquant.", "error")
+        return redirect(url_for('user_bp.dashboard'))
+        
+    if not user_data:
+        flash("Utilisateur non trouvé.", "error")
+        return redirect(url_for('web_bp.connexion_page')) 
+
+    # 4. Extraction du nom du dépôt
+    repo_name = repo_slug.split('/')[-1]
+
+    # 5. Préparation du contexte
+    context = {
+        'user': user_data,
+        'repo_slug': repo_slug, 
+        'repo_name': repo_name,
+        # *** PARAMÈTRE CLÉ AJOUTÉ AU CONTEXTE ***
+        'current_branch': current_branch 
+    }
+
+    # 6. Rendu du template (le frontend utilisera 'current_branch' pour ses appels API)
+    return render_template('repo_files_branch.html', **context)

a6ea61c8-951a-413a-ba9d-7365d83fbd4d/mayproject/web_routes.py

@@ -0,0 +1,210 @@
+# web_routes.py (Version SSR - Ajout des routes publiques et conservation des APIs)
+from decorators import api_session_required, login_required 
+import shutil
+# AJOUT DE RENDER_TEMPLATE ET URL_FOR
+from flask import Blueprint, request, jsonify, send_from_directory, current_app, session, render_template, redirect, url_for 
+from werkzeug.utils import secure_filename 
+import os 
+import uuid 
+import json
+from auth_backend import get_plan_details 
+from baserow_storage import get_health_status, update_user_deployment_data, get_deployment_by_id, save_new_repository, delete_deployment_by_id, save_new_repository, get_all_user_repositories 
+import huggingface_storage
+from huggingface_repo_manager import (
+    create_empty_repo_folder_on_hf, 
+    list_repo_files_from_hf 
+)
+from datetime import datetime 
+
+# NOUVEAU : Fonction pour vérifier les extensions autorisées pour le déploiement statique
+def allowed_static_file(filename):
+    """Vérifie si le fichier a une extension autorisée (HTML, CSS, JS, Images)."""
+    STATIC_ALLOWED_EXTENSIONS = {'html', 'htm', 'css', 'js', 'jpg', 'jpeg', 'png', 'gif', 'svg'}
+    return '.' in filename and \
+           filename.rsplit('.', 1)[1].lower() in STATIC_ALLOWED_EXTENSIONS
+
+# Création du Blueprint 'web_bp'
+web_bp = Blueprint('web_bp', __name__)
+
+# ----------------------------------------------------------------------
+# ROUTES D'AFFICHAGE STATIQUE/DE PAGES (SSR - Rendu Côté Serveur)
+# ----------------------------------------------------------------------
+
+# Mapping pour les noms de route standards pour les redirections
+PAGE_ROUTE_MAPPING = {
+    "index": "index.html",
+    "connexion_page": "connexion.html",
+    "inscription_page": "inscription.html",
+    "mot_de_passe_oublie_page": "mot_de_passe_oublie.html",
+    "tarifs_page": "tarifs.html",
+    "documentation_page": "documentation.html",
+    "support_page": "support.html",
+    "a_propos_page": "a_propos.html",
+    "mentions_legales_page": "mentions_legales.html",
+    "politique_confidentialite_page": "politique_confidentialite.html",
+    "conditions_utilisation_page": "conditions_utilisation.html",
+    # Ajoutez d'autres pages non sécurisées ici
+}
+
+# Liste des fichiers HTML non sécurisés
+PUBLIC_PAGES = [
+    "index.html",
+    "connexion.html",
+    "inscription.html",
+    "mot_de_passe_oublie.html",
+    "tarifs.html",
+    "documentation.html",
+    "support.html",
+    "a_propos.html",
+    "mentions_legales.html",
+    "politique_confidentialite.html",
+    "conditions_utilisation.html",
+    "blog.html",
+    "careers.html",
+    "resources.html",
+    "devsecops.html",
+    "devops.html",
+    "customers_stories.html",
+    "all_stories.html",
+    "form_gitforge.html",
+]
+
+for page in PUBLIC_PAGES:
+    # Nom de la fonction basé sur le nom du fichier pour les url_for
+    route_name = page.replace('.html', '_page').replace('-', '_')
+    
+    # --- MODIFICATION ICI : On retire l'extension .html du chemin de la route ---
+    route_path = f"/mindus/nexus/{page.replace('.html', '')}" # Exemple: /mindus/nexus/connexion
+    
+    @web_bp.route(route_path, endpoint=route_name)
+    def public_page_renderer(page=page):
+        # Toutes les pages publiques sont servies avec render_template
+        # Le nom du template reste 'connexion.html' (page), mais l'URL est 'connexion' (route_path)
+        return render_template(page)
+
+
+# Route racine de l'application
+@web_bp.route("/")
+def home():
+    # Redirige vers la page d'accueil principale /mindus/nexus/index (sans .html)
+    # url_for utilise le nom d'endpoint, qui pointe désormais vers l'URL sans extension.
+    return redirect(url_for('web_bp.index_page'))
+
+
+@web_bp.route('/api/create_repository', methods=['POST'])
+@api_session_required # ⬅️ CHANGEMENT CLÉ : Utiliser le décorateur API basé sur la session
+def create_repository(client_user): # ⬅️ CHANGEMENT CLÉ : Accepter l'objet utilisateur injecté
+    """
+    Point API pour créer un nouveau dépôt utilisateur.
+    L'utilisateur est authentifié et fourni par le décorateur @api_session_required via la session.
+    """
+    
+    # 1. Récupération de l'ID utilisateur à partir de l'objet injecté
+    # L'authentification (vérification de la session) est gérée par le décorateur.
+    user_id = client_user['uuid'] 
+    
+    data = request.get_json()
+    
+    # L'ancienne vérification 'if not user_id' est désormais gérée par le décorateur.
+    
+    if not data or 'repo-name' not in data or 'visibility' not in data:
+        return jsonify({"success": False, "message": "Nom et visibilité du dépôt requis."}), 400
+
+    repo_name = data.get('repo-name').strip()
+    # Créer un slug simple pour le chemin HF et l'URL
+    # secure_filename doit être importé de werkzeug.utils
+    repo_slug = secure_filename(repo_name).lower().replace('-', '_') 
+    
+    if not repo_slug:
+        return jsonify({"success": False, "message": "Nom de dépôt invalide."}), 400
+        
+    # Validation basique des données
+    visibility = data.get('visibility')
+    if visibility not in ['public', 'private']:
+        return jsonify({"success": False, "message": "Visibilité invalide."}), 400
+
+    # 1. Vérification des limites de plan (À implémenter plus tard si besoin)
+    # limit = get_plan_limit(client_user.get('user_plan')) 
+
+    # 2. Vérification de l'existence du slug (pour s'assurer que l'utilisateur ne crée pas de doublon)
+    existing_repos = get_all_user_repositories(user_id)
+    if any(repo['repo_slug'] == repo_slug for repo in existing_repos):
+          return jsonify({"success": False, "message": f"Un dépôt avec le nom '{repo_name}' existe déjà."}), 409
+    
+    # 3. Préparation des données du nouveau dépôt
+    repo_id = str(uuid.uuid4()) # ID unique pour le dépôt
+    new_repo_data = {
+        "repo_id": repo_id,
+        "repo_name": repo_name,
+        "repo_slug": repo_slug,
+        "user_id": user_id, # ⬅️ ID utilisateur récupéré et correctement utilisé
+        "visibility": visibility,
+        "license": data.get('license', 'None'),
+        "description": data.get('description', ''),
+        "created_at": datetime.now().isoformat()
+    }
+    
+    try:
+        # 4. Enregistrement dans Baserow (Base de Données)
+        success_db, message_db = save_new_repository(user_id, new_repo_data)
+        
+        if not success_db:
+              return jsonify({"success": False, "message": f"Échec de l'enregistrement du dépôt: {message_db}"}), 500
+        
+        # 5. Création du dossier initial sur Hugging Face (Stockage de fichiers)
+        success_hf, message_hf = create_empty_repo_folder_on_hf(repo_slug, str(user_id))
+        
+        if not success_hf:
+            # On log l'erreur et on retourne quand même un succès BDD, mais un avertissement
+            current_app.logger.error(f"Échec de l'initialisation HF pour {repo_slug}: {message_hf}")
+            return jsonify({
+                "success": True, 
+                "message": f"Dépôt créé dans la BDD. Avertissement: Échec de l'initialisation du dossier sur Hugging Face ({message_hf}).",
+                "repo_slug": repo_slug
+            }), 201
+
+        # 6. Succès
+        return jsonify({
+            "success": True, 
+            "message": "Dépôt créé avec succès.",
+            "repo_slug": repo_slug
+        }), 201
+
+    except Exception as e:
+        # current_app doit être importé de flask
+        current_app.logger.error(f"Erreur inattendue lors de la création du dépôt: {e}")
+        return jsonify({"success": False, "message": "Erreur serveur inattendue."}), 500
+
+@web_bp.route('/api/repository_files/<repo_slug>', methods=['GET'])
+@login_required
+def get_repository_files(repo_slug):
+    """
+    Point API pour retourner tous les fichiers du dépôt spécifié par son slug, 
+    en listant le contenu du Dataset Hugging Face.
+    """
+    user_id = session.get('user_id')
+    
+    if not user_id:
+        return jsonify({"success": False, "message": "Session utilisateur requise."}), 401
+
+    # 1. Vérification rapide de l'existence du dépôt dans la BDD
+    existing_repos = get_all_user_repositories(user_id)
+    repo_info = next((repo for repo in existing_repos if repo['repo_slug'] == repo_slug), None)
+
+    if not repo_info:
+        return jsonify({"success": False, "message": "Dépôt non trouvé ou accès non autorisé."}), 404
+
+    # 2. Récupération des fichiers depuis Hugging Face
+    file_list, message = list_repo_files_from_hf(repo_slug, str(user_id))
+    
+    if file_list is not None:
+        # Succès (même si la liste est vide)
+        return jsonify({
+            "success": True, 
+            "message": message,
+            "repo_info": repo_info,
+            "files": file_list
+        }), 200
+    else:
+        # Échec de la récupération (ex: erreur de connexion HF)
+        return jsonify({"success": False, "message": message}), 500