/sess_* (format actuel)
+ - /sess_* (ancien format, sessions au niveau racine)
+ """
+ base = _resolve_sessions_dir()
+ if not base.is_dir():
+ logger.warning("Repertoire live_sessions introuvable : %s", base)
+ return []
+
+ sessions: List[Dict[str, Any]] = []
+
+ for item in base.iterdir():
+ if not item.is_dir():
+ continue
+
+ # Sessions directement a la racine (ancien format)
+ if item.name.startswith("sess_"):
+ jsonl = item / "live_events.jsonl"
+ if jsonl.is_file():
+ sessions.append(_build_session_info("(racine)", item.name, item, jsonl))
+ continue
+
+ # Ignorer les dossiers systeme
+ if item.name.startswith(".") or item.name in ("embeddings", "streaming_sessions", "workflows", "test_gpu"):
+ continue
+
+ # Sous-dossiers machine_id
+ for sub in item.iterdir():
+ if sub.is_dir() and sub.name.startswith("sess_"):
+ jsonl = sub / "live_events.jsonl"
+ if jsonl.is_file():
+ sessions.append(_build_session_info(item.name, sub.name, sub, jsonl))
+
+ # Tri par date decroissante (mtime du JSONL)
+ sessions.sort(key=lambda s: s["mtime"], reverse=True)
+ return sessions[:limit]
+
+
+def _build_session_info(machine_id: str, session_id: str, session_dir: Path, jsonl_path: Path) -> Dict[str, Any]:
+ """Construire les metadonnees d'une session."""
+ mtime = jsonl_path.stat().st_mtime
+ event_count = 0
+ try:
+ with open(jsonl_path, encoding="utf-8") as f:
+ for line in f:
+ if line.strip():
+ event_count += 1
+ except OSError:
+ pass
+
+ # Extraire la date depuis le nom de session (sess_YYYYMMDDTHHMMSS_...)
+ date_str = ""
+ try:
+ parts = session_id.split("_")
+ if len(parts) >= 2:
+ raw = parts[1] # 20260410T222352
+ dt = datetime.strptime(raw, "%Y%m%dT%H%M%S")
+ date_str = dt.strftime("%d/%m/%Y %H:%M:%S")
+ except (ValueError, IndexError):
+ date_str = datetime.fromtimestamp(mtime).strftime("%d/%m/%Y %H:%M:%S")
+
+ return {
+ "machine_id": machine_id,
+ "session_id": session_id,
+ "session_dir": str(session_dir),
+ "date_str": date_str,
+ "event_count": event_count,
+ "mtime": mtime,
+ }
+
+
+def _load_events(session_dir: Path) -> List[Dict[str, Any]]:
+ """Charger les evenements depuis live_events.jsonl."""
+ jsonl = session_dir / "live_events.jsonl"
+ events: List[Dict[str, Any]] = []
+ if not jsonl.is_file():
+ return events
+ try:
+ with open(jsonl, encoding="utf-8") as f:
+ for line in f:
+ line = line.strip()
+ if line:
+ try:
+ events.append(json.loads(line))
+ except json.JSONDecodeError:
+ continue
+ except OSError as e:
+ logger.error("Erreur lecture %s : %s", jsonl, e)
+ return events
+
+
+def _get_window_title(event: Dict[str, Any]) -> str:
+ """Extraire le titre de fenetre d'un evenement.
+
+ Les evenements plus recents stockent la fenetre dans event.window.title,
+ les anciens dans event.active_window_title.
+ """
+ inner = event.get("event", {})
+ # Format actuel : inner.window.title
+ window = inner.get("window") or {}
+ if isinstance(window, dict) and window.get("title"):
+ return window["title"]
+ # Ancien format
+ return inner.get("active_window_title", "")
+
+
+def _get_shot_filename(click_index: int, session_dir: Path) -> Optional[str]:
+ """Trouver le fichier screenshot pour un clic donne.
+
+ Essaie dans l'ordre :
+ 1. shot_XXXX_crop.png (ancien format)
+ 2. shot_XXXX_full.png (ancien format)
+ 3. res_shot_XXXX.png (format recent — resultat post-action)
+
+ ``click_index`` est 1-based (premier clic = 1).
+ """
+ shots_dir = session_dir / "shots"
+ if not shots_dir.is_dir():
+ return None
+
+ shot_id = f"shot_{click_index:04d}"
+
+ # Priorite au crop (plus informatif en thumbnail)
+ for pattern in [f"{shot_id}_crop.png", f"{shot_id}_full.png", f"res_{shot_id}.png"]:
+ if (shots_dir / pattern).is_file():
+ return pattern
+
+ return None
+
+
+def _is_parasitic(event: Dict[str, Any], index: int, total: int) -> bool:
+ """Determiner si un evenement est probablement parasite.
+
+ Criteres :
+ - Fenetre contenant un pattern parasite (systray, Program Manager, Lea, etc.)
+ - Clic droit
+ - Types non-exploitables (heartbeat, focus_change, action_result)
+ - Parmi les 3 derniers evenements (souvent = arret enregistrement)
+ """
+ inner = event.get("event", {})
+ etype = inner.get("type", "")
+
+ # Types toujours parasites
+ if etype in ("heartbeat", "focus_change", "window_focus_change", "action_result",
+ "screenshot", "status", "ping", "pong"):
+ return True
+
+ # Clics droit
+ if etype == "mouse_click" and inner.get("button") == "right":
+ return True
+
+ # Fenetre parasite
+ win_title = _get_window_title(event).lower()
+ if win_title:
+ for pattern in _PARASITIC_WINDOW_PATTERNS:
+ if pattern in win_title:
+ return True
+
+ # Derniers 3 evenements exploitables de la session
+ # (on les marque UNIQUEMENT si c'est un evenement exploitable, pas un heartbeat)
+ if etype in _ACTIONABLE_TYPES and index >= total - 3:
+ return True
+
+ return False
+
+
+def _parse_actions(events: List[Dict[str, Any]], session_dir: Path) -> List[Dict[str, Any]]:
+ """Convertir les evenements bruts en liste d'actions affichables.
+
+ Retourne une liste de dicts avec : index_global, type, position, fenetre,
+ texte, touches, shot_file, is_parasitic, etc.
+ """
+ actions: List[Dict[str, Any]] = []
+ click_count = 0
+ total_events = len(events)
+
+ # Pre-calculer les 3 derniers indices d'evenements exploitables
+ actionable_indices = [
+ i for i, ev in enumerate(events)
+ if ev.get("event", {}).get("type", "") in _ACTIONABLE_TYPES
+ ]
+ last_3_actionable = set(actionable_indices[-3:]) if len(actionable_indices) >= 3 else set(actionable_indices)
+
+ for i, event in enumerate(events):
+ inner = event.get("event", {})
+ etype = inner.get("type", "")
+
+ # Ne montrer que les evenements exploitables
+ if etype not in _ACTIONABLE_TYPES:
+ continue
+
+ action: Dict[str, Any] = {
+ "global_index": i,
+ "type": etype,
+ "position": "",
+ "window_title": _get_window_title(event),
+ "text": "",
+ "keys": "",
+ "shot_file": None,
+ "is_parasitic": False,
+ }
+
+ # Position (pour les clics)
+ pos = inner.get("pos")
+ if pos and isinstance(pos, (list, tuple)) and len(pos) >= 2:
+ action["position"] = f"({pos[0]}, {pos[1]})"
+
+ # Bouton de clic
+ if etype == "mouse_click":
+ action["button"] = inner.get("button", "left")
+ click_count += 1
+ action["shot_file"] = _get_shot_filename(click_count, session_dir)
+ action["click_number"] = click_count
+
+ # Texte tape
+ if etype in ("text_input", "type"):
+ action["text"] = inner.get("text", "")
+
+ # Touches pour key_combo / key_press
+ if etype in ("key_combo", "key_press"):
+ keys = inner.get("keys", [])
+ if isinstance(keys, list):
+ action["keys"] = " + ".join(str(k) for k in keys)
+ else:
+ action["keys"] = str(inner.get("key", keys))
+
+ # Detection parasite
+ # Utiliser les 3 derniers indices exploitables (pas les indices globaux)
+ parasitic = False
+ inner_type = etype
+
+ # Clic droit
+ if inner_type == "mouse_click" and inner.get("button") == "right":
+ parasitic = True
+
+ # Fenetre parasite
+ win_lower = action["window_title"].lower()
+ if win_lower:
+ for pattern in _PARASITIC_WINDOW_PATTERNS:
+ if pattern in win_lower:
+ parasitic = True
+ break
+
+ # Derniers 3 evenements exploitables
+ if i in last_3_actionable:
+ parasitic = True
+
+ action["is_parasitic"] = parasitic
+ actions.append(action)
+
+ return actions
+
+
+# ---------------------------------------------------------------------------
+# Templates HTML
+# ---------------------------------------------------------------------------
+
+_BASE_CSS = """
+body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+ margin: 0; padding: 20px; background: #f5f5f5; color: #333; }
+h1 { color: #2c3e50; border-bottom: 2px solid #3498db; padding-bottom: 10px; }
+h2 { color: #34495e; }
+a { color: #2980b9; text-decoration: none; }
+a:hover { text-decoration: underline; }
+table { border-collapse: collapse; width: 100%; background: white; border-radius: 6px;
+ overflow: hidden; box-shadow: 0 1px 3px rgba(0,0,0,0.12); }
+th { background: #2c3e50; color: white; padding: 12px 15px; text-align: left; }
+td { padding: 10px 15px; border-bottom: 1px solid #eee; }
+tr:hover { background: #f0f7ff; }
+.btn { display: inline-block; padding: 10px 20px; background: #e74c3c; color: white;
+ border: none; border-radius: 4px; cursor: pointer; font-size: 14px; }
+.btn:hover { background: #c0392b; }
+.btn-secondary { background: #3498db; }
+.btn-secondary:hover { background: #2980b9; }
+.info-box { background: #eaf4ff; border: 1px solid #b8d4f0; border-radius: 6px;
+ padding: 15px; margin: 15px 0; }
+.warning-box { background: #fff3cd; border: 1px solid #ffc107; border-radius: 6px;
+ padding: 15px; margin: 15px 0; }
+.success-box { background: #d4edda; border: 1px solid #28a745; border-radius: 6px;
+ padding: 15px; margin: 15px 0; }
+.error-box { background: #f8d7da; border: 1px solid #dc3545; border-radius: 6px;
+ padding: 15px; margin: 15px 0; }
+.parasitic { background: #ffe0e0; }
+.normal { background: #e0ffe0; }
+.counter { font-size: 18px; font-weight: bold; margin: 15px 0; }
+.counter .remove { color: #e74c3c; }
+.counter .total { color: #2c3e50; }
+img.thumb { max-height: 80px; border: 1px solid #ccc; border-radius: 4px; cursor: pointer; }
+img.thumb:hover { box-shadow: 0 2px 8px rgba(0,0,0,0.3); }
+.nav { margin-bottom: 20px; }
+.mono { font-family: 'Fira Code', 'Consolas', monospace; font-size: 13px; }
+label { cursor: pointer; }
+"""
+
+_INDEX_TEMPLATE = """
+
+
+
+
+ Session Cleaner -- Lea
+
+
+
+ Session Cleaner
+ Outil de nettoyage des sessions avant replay. Selectionnez une session pour voir ses actions.
+
+ {% if sessions %}
+
+
+
+ | Date |
+ Machine |
+ Session ID |
+ Evenements |
+ Action |
+
+
+
+ {% for s in sessions %}
+
+ | {{ s.date_str }} |
+ {{ s.machine_id }} |
+ {{ s.session_id }} |
+ {{ s.event_count }} |
+ Voir |
+
+ {% endfor %}
+
+
+ {% else %}
+
+
Aucune session trouvee dans {{ sessions_dir }}.
+
Lancez un enregistrement depuis l'Agent V1 pour creer des sessions.
+
Session : {{ session_id }}
+
+ Machine : {{ machine_id }} |
+ Date : {{ date_str }} |
+ Evenements bruts : {{ total_events }}
+
+
+ {% if actions %}
+
+ {{ parasitic_count }} actions a supprimer /
+ {{ actions|length }} total
+
+
+
+ {% else %}
+
+ Aucune action exploitable dans cette session.
+
+ {% endif %}
+
+
+
+
![Screenshot agrandi]()
+
Replay lance
+
+ {% if success %}
+
+
Replay demarre avec succes.
+
Replay ID : {{ replay_id }}
+
Session : {{ session_id }}
+
Machine cible : {{ machine_id }}
+
Actions injectees : {{ action_count }}
+
Actions supprimees : {{ removed_count }}
+
+
Erreur lors du lancement du replay.
+
{{ error_message }}
+
Session {{ sid }}
+ introuvable pour la machine {{ mid }}.