"""``hermes sessions repair-profiles`` — the CLI face of :mod:`hermes_cli.sessions_repair_profiles`. Runs pre-DB (``_PRE_DB_HANDLERS``): it opens every profile's store itself rather than the one ambient ``SessionDB()``. Report-only unless ``--apply``; ``--json`` for automation. """ from __future__ import annotations import json import sys from typing import Dict, List from hermes_cli.sessions_repair_profiles import ( Finding, default_snapshot, enumerate_stores, live_gateway_homes, scan_stores, ) _KIND_LABELS = { "mislabelled": "profile_name disagrees with the row's own session key", "wrong_store": "rows in another profile's store", "legacy_main": "legacy agent:main rows inside a named profile's store", "unclaimed_namespace": "rows keyed to a profile that does not exist", "crossed_parent": "parent_session_id crossing profile namespaces", "routing_stray": "routing rows outside the default store", "routing_unclaimed": "routing rows for a profile that does not exist", "topic_profile_less": "Telegram topic bindings without their bot's profile", "voice_profile_less": "voice-mode entries without their bot's profile", "sessions_json_unclaimed": "sessions.json entries for a profile that does not exist", } def _group(findings: list[Finding]) -> dict[str, list[Finding]]: grouped: dict[str, list[Finding]] = {} for finding in findings: grouped.setdefault(finding.kind, []).append(finding) return grouped def _print_report(findings: list[Finding]) -> None: for kind, rows in _group(findings).items(): print(f"\n{_KIND_LABELS.get(kind, kind)} ({len(rows)}):") for finding in rows: print(f" [{finding.store}] {finding.subject}\n {finding.detail}") if finding.action: print(f" → {finding.action}") else: print(f" ✗ not repaired — {finding.reason}") def cmd_repair_profiles(args) -> int: stores = enumerate_stores() apply = bool(getattr(args, "apply", False)) as_json = bool(getattr(args, "json", False)) legacy_main = getattr(args, "legacy_main", None) or "report" if apply: # Before any store is opened for write: a writable open runs schema init, and a live # gateway holds the routing index in memory and would write it back over the repair. live = live_gateway_homes(stores) if live: names = ", ".join(f"{profile} (pid {pid})" for profile, pid in live) print(f"A gateway is running for: {names}. It holds the routing index in memory and would " "write it back over this repair. Stop it (`hermes gateway stop`), then re-run --apply.", file=sys.stderr) return 1 plan, session = scan_stores(stores, legacy_main=legacy_main, read_only=not apply) try: findings = plan.findings repairable = plan.repairable if as_json and not apply: print(json.dumps({"stores": [s.profile for s in stores], "findings": [f.as_dict() for f in findings], "repairable": len(repairable)}, indent=2)) return 0 if not as_json: print(f"Scanned {len(stores)} profile store(s): {', '.join(s.profile for s in stores)}") if not findings: print("✓ No crossed-profile state found.") return 0 _print_report(findings) if not apply: print(f"\n{len(repairable)} of {len(findings)} finding(s) can be repaired. " "Re-run with --apply to perform them.") return 0 if not repairable: if as_json: print(json.dumps({"findings": [f.as_dict() for f in findings], "applied": {}}, indent=2)) else: print("\nNothing to repair.") return 0 if not getattr(args, "yes", False) and not as_json: from hermes_cli.sessions_cmd import _confirm_or_exit_code refused = _confirm_or_exit_code( f"\nApply {len(repairable)} repair(s)? A snapshot of every store is taken first. [y/N] ", declined="Aborted — nothing was changed.") if refused is not None: return refused result = plan.apply(session, snapshot=default_snapshot) finally: session.close() if as_json: print(json.dumps({"findings": [f.as_dict() for f in findings], "applied": result}, indent=2)) else: for profile, snap in result["snapshots"].items(): print(f" snapshot [{profile}]: {snap or 'FAILED'}") applied = ", ".join(f"{k}={v}" for k, v in sorted(result["totals"].items()) if v) print(f"\nApplied: {applied or 'nothing'}") for failure in result["failures"]: print(f" ✗ {failure['kind']} {failure['subject']}: {failure['error']}") print("Re-run without --apply to confirm the stores are clean.") return 1 if result["failures"] else 0