feat: ajouter le keepalive SSH et la reconnexion automatique

- Session gagne keepalive_enabled/interval/count_max (actif par defaut : ne
  fait qu'envoyer des paquets de maintien, sans risque pour les sessions
  existantes) et reconnect_enabled/initial_delay/max_attempts (desactive par
  defaut : change reellement le comportement en cas de coupure, donc a
  activer explicitement).

- SSHConnection._keepalive_loop() : thread dedie qui envoie
  "keepalive@openssh.com" (comme OpenSSH) avec accuse de reception toutes les
  `keepalive_interval` secondes. Un serveur conforme repond immediatement
  (meme en echec), ce qui confirme que le transport est vivant. Apres
  `keepalive_count_max` echecs consecutifs (aucune reponse), le canal est
  ferme pour que la boucle de lecture principale s'en apercoive et emette
  `disconnected` avec une raison explicite.

- SessionTabWidget programme une reconnexion (QTimer, jamais de blocage de
  l'interface) quand la session l'autorise et que la deconnexion n'est pas
  volontaire (_closing) : delai en backoff exponentiel plafonne
  (app.services.reconnect.compute_backoff_delay), compte a rebours affiche
  ("Connexion perdue (...). Reconnexion dans Ns... (Tentative X/Y)"), abandon
  au-dela de reconnect_max_attempts (0 = illimite), compteur remis a zero des
  qu'une connexion reussit. Ne se declenche jamais sur une simple erreur
  d'authentification (seul un `disconnected` apres connexion reussie
  declenche une reconnexion, pas un `error` de connexion initiale - sinon un
  mot de passe errone entrainerait des tentatives repetees).

- BaseTerminalTab : les signaux connected/disconnected/error d'une connexion
  sont desormais associes a la generation de connexion en cours au moment ou
  ils sont cables ; un signal parvenant apres qu'une reconnexion (manuelle ou
  automatique) ait deja demarre une nouvelle connexion est ignore. Necessaire
  ici : les signaux Qt entre threads sont mis en file et ne sont livres
  qu'apres le retour de reconnect() a la boucle d'evenements, alors qu'une
  nouvelle connexion est deja en place.

- SessionDialog : sections "Keepalive" et "Reconnexion automatique".

tests/test_keepalive.py (paramiko entierement mocke), test_reconnect_backoff.py
(fonction pure) et test_auto_reconnect.py (SSHConnection.start() neutralisee :
la programmation de la reconnexion ne depend d'aucune connexion reseau reelle).

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

app/dialogs/session_dialog.py

@@ -80,6 +80,8 @@ class SessionDialog(QDialog):
 
         layout.addLayout(form)
         layout.addWidget(self._build_bastion_group())
+        layout.addWidget(self._build_keepalive_group())
+        layout.addWidget(self._build_reconnect_group())
 
         self.save_check = QCheckBox("Enregistrer dans mes sessions (optionnel)")
         if self.quick_mode:
@@ -260,6 +262,59 @@ class SessionDialog(QDialog):
             bastion.key_path = self.bastion_key_combo.currentData() or ""
         return bastion
 
+    # ---------- Keepalive ----------
+    def _build_keepalive_group(self) -> QGroupBox:
+        session = self.session
+        group = QGroupBox("Keepalive")
+        form = QFormLayout(group)
+
+        self.keepalive_check = QCheckBox("Active")
+        self.keepalive_check.setChecked(session.keepalive_enabled)
+        self.keepalive_interval_spin = QSpinBox()
+        self.keepalive_interval_spin.setRange(5, 3600)
+        self.keepalive_interval_spin.setSuffix(" s")
+        self.keepalive_interval_spin.setValue(session.keepalive_interval or 30)
+        self.keepalive_count_spin = QSpinBox()
+        self.keepalive_count_spin.setRange(1, 20)
+        self.keepalive_count_spin.setValue(session.keepalive_count_max or 3)
+
+        form.addRow(self.keepalive_check)
+        form.addRow("Intervalle :", self.keepalive_interval_spin)
+        form.addRow("Nombre d'echecs avant abandon :", self.keepalive_count_spin)
+
+        self.keepalive_check.toggled.connect(self.keepalive_interval_spin.setEnabled)
+        self.keepalive_check.toggled.connect(self.keepalive_count_spin.setEnabled)
+        self.keepalive_interval_spin.setEnabled(session.keepalive_enabled)
+        self.keepalive_count_spin.setEnabled(session.keepalive_enabled)
+        return group
+
+    # ---------- Reconnexion automatique ----------
+    def _build_reconnect_group(self) -> QGroupBox:
+        session = self.session
+        group = QGroupBox("Reconnexion automatique")
+        form = QFormLayout(group)
+
+        self.reconnect_check = QCheckBox("Reconnexion automatique")
+        self.reconnect_check.setChecked(session.reconnect_enabled)
+        self.reconnect_delay_spin = QSpinBox()
+        self.reconnect_delay_spin.setRange(1, 300)
+        self.reconnect_delay_spin.setSuffix(" s")
+        self.reconnect_delay_spin.setValue(session.reconnect_initial_delay or 5)
+        self.reconnect_attempts_spin = QSpinBox()
+        self.reconnect_attempts_spin.setRange(0, 1000)
+        self.reconnect_attempts_spin.setSpecialValueText("Illimite")
+        self.reconnect_attempts_spin.setValue(session.reconnect_max_attempts)
+
+        form.addRow(self.reconnect_check)
+        form.addRow("Delai initial :", self.reconnect_delay_spin)
+        form.addRow("Tentatives maximum (0 = illimite) :", self.reconnect_attempts_spin)
+
+        self.reconnect_check.toggled.connect(self.reconnect_delay_spin.setEnabled)
+        self.reconnect_check.toggled.connect(self.reconnect_attempts_spin.setEnabled)
+        self.reconnect_delay_spin.setEnabled(session.reconnect_enabled)
+        self.reconnect_attempts_spin.setEnabled(session.reconnect_enabled)
+        return group
+
     def should_save(self) -> bool:
         """En connexion rapide, indique si la session doit aussi etre enregistree."""
         return self.save_check.isChecked() if self.quick_mode else True
@@ -305,6 +360,12 @@ class SessionDialog(QDialog):
         self.session.key_path = self.key_combo.currentData() or ""
         self.session.notes = self.notes_edit.toPlainText()
         self.session.bastion = self._result_bastion()
+        self.session.keepalive_enabled = self.keepalive_check.isChecked()
+        self.session.keepalive_interval = self.keepalive_interval_spin.value()
+        self.session.keepalive_count_max = self.keepalive_count_spin.value()
+        self.session.reconnect_enabled = self.reconnect_check.isChecked()
+        self.session.reconnect_initial_delay = self.reconnect_delay_spin.value()
+        self.session.reconnect_max_attempts = self.reconnect_attempts_spin.value()
         self.accept()
 
     def result_session(self) -> Session:

app/services/reconnect.py

@@ -0,0 +1,12 @@
+"""Calcul du delai de reconnexion automatique (backoff exponentiel plafonne)."""
+from __future__ import annotations
+
+
+def compute_backoff_delay(attempt: int, initial_delay: int, max_delay: int = 60) -> int:
+    """Delai (secondes) avant la tentative numero `attempt` (1, 2, 3, ...).
+
+    Double a chaque tentative (5s, 10s, 20s, 40s, ...) et plafonne a `max_delay`
+    pour ne pas finir par attendre des heures apres de nombreux echecs."""
+    if attempt < 1:
+        attempt = 1
+    return min(initial_delay * (2 ** (attempt - 1)), max_delay)

app/session_manager.py

@@ -66,6 +66,19 @@ class Session:
     notes: str = ""
     bastion: BastionConfig = field(default_factory=BastionConfig)
 
+    # Keepalive : sans risque pour une session existante (n'envoie que des
+    # paquets de maintien de connexion), active par defaut.
+    keepalive_enabled: bool = True
+    keepalive_interval: int = 30
+    keepalive_count_max: int = 3
+
+    # Reconnexion automatique : change reellement le comportement en cas de
+    # coupure, donc desactivee par defaut pour ne pas surprendre les sessions
+    # existantes ; a activer explicitement.
+    reconnect_enabled: bool = False
+    reconnect_initial_delay: int = 5
+    reconnect_max_attempts: int = 10  # 0 = illimite
+
     def to_dict(self) -> dict:
         return asdict(self)
 

app/ssh_connection.py

@@ -57,6 +57,9 @@ class SSHConnection(QThread):
         open_sftp_on_connect: bool = False,
         bastion_target: BastionTarget | None = None,
         bastion_password: str = "",
+        keepalive_enabled: bool = False,
+        keepalive_interval: int = 30,
+        keepalive_count_max: int = 3,
         parent=None,
     ):
         super().__init__(parent)
@@ -74,11 +77,16 @@ class SSHConnection(QThread):
         self.rows = rows
         self.bastion_target = bastion_target
         self.bastion_password = bastion_password
+        self.keepalive_enabled = keepalive_enabled
+        self.keepalive_interval = max(1, keepalive_interval)
+        self.keepalive_count_max = max(1, keepalive_count_max)
 
         self.client: paramiko.SSHClient | None = None
         self.channel: paramiko.Channel | None = None
         self._bastion_client: paramiko.SSHClient | None = None
         self._stop = threading.Event()
+        self._disconnect_reason = "Connexion fermee"
+        self._keepalive_thread: threading.Thread | None = None
 
         self._trust_event = threading.Event()
         self._trust_result = False
@@ -259,6 +267,44 @@ class SSHConnection(QThread):
                 f"{self.host}:{self.port} ({exc})"
             ) from exc
 
+    # ---------- keepalive (ServerAliveInterval / ServerAliveCountMax) ----------
+    def _start_keepalive(self) -> None:
+        if not self.keepalive_enabled:
+            return
+        self._keepalive_thread = threading.Thread(target=self._keepalive_loop, daemon=True)
+        self._keepalive_thread.start()
+
+    def _keepalive_loop(self) -> None:
+        """Envoie une requete keepalive avec accuse de reception toutes les
+        `keepalive_interval` secondes. Apres `keepalive_count_max` echecs
+        consecutifs (pas de reponse : transport mort), force la fermeture du
+        canal pour que la boucle de lecture principale s'en apercoive et
+        declenche la deconnexion (et, si activee, la reconnexion automatique)."""
+        failures = 0
+        while not self._stop.wait(self.keepalive_interval):
+            transport = self.client.get_transport() if self.client else None
+            if not transport or not transport.is_active():
+                return
+            try:
+                # Nom choisi comme celui d'OpenSSH : un serveur conforme repond
+                # "request failed" immediatement, ce qui suffit a confirmer que
+                # le transport est bien vivant (le contenu de la reponse importe peu).
+                transport.global_request("keepalive@openssh.com", wait=True)
+                failures = 0
+            except Exception:  # noqa: BLE001
+                failures += 1
+                if failures >= self.keepalive_count_max:
+                    self._disconnect_reason = (
+                        f"keepalive : aucune reponse apres {failures} tentative(s)"
+                    )
+                    self._stop.set()
+                    try:
+                        if self.channel:
+                            self.channel.close()
+                    except Exception:
+                        pass
+                    return
+
     # ---------- cycle de vie du thread ----------
     def run(self) -> None:
         try:
@@ -283,12 +329,14 @@ class SSHConnection(QThread):
                     if not self.open_shell:
                         raise
 
+            self._start_keepalive()
+
             if not self.open_shell:
                 # Connexion dediee au SFTP : on garde la session vivante sans shell.
                 self.connected.emit()
                 while not self._stop.is_set():
                     self._stop.wait(0.2)
-                self.disconnected.emit("Connexion fermee")
+                self.disconnected.emit(self._disconnect_reason)
                 return
 
             self.channel = self.client.invoke_shell(term="xterm-256color", width=self.cols, height=self.rows)
@@ -315,7 +363,7 @@ class SSHConnection(QThread):
                 except Exception:
                     break
 
-            self.disconnected.emit("Connexion fermee")
+            self.disconnected.emit(self._disconnect_reason)
         except paramiko.AuthenticationException:
             self.error.emit("Authentification refusee (identifiants ou cle invalides).")
         except Exception as exc:  # noqa: BLE001

app/ui/tabs.py

@@ -11,7 +11,7 @@ import re
 from datetime import datetime
 from pathlib import Path
 
-from PySide6.QtCore import Qt, Signal
+from PySide6.QtCore import Qt, Signal, QTimer
 from PySide6.QtGui import QKeySequence, QShortcut
 from PySide6.QtWidgets import (
     QWidget, QVBoxLayout, QHBoxLayout, QToolButton, QLabel, QMessageBox, QSplitter,
@@ -27,6 +27,7 @@ from app.dialogs.tunnel_dialog import TunnelDialog
 from app.tunnels import TunnelManager
 from app.dialogs.connect_prompt import ask_secret, confirm_host_key, confirm_host_key_change
 from app.services.ssh_target import detect_ssh_target
+from app.services.reconnect import compute_backoff_delay
 
 # sequences d'echappement ANSI, retirees des journaux pour qu'ils restent lisibles
 ANSI_ESCAPE_RE = re.compile(
@@ -104,6 +105,8 @@ class BaseTerminalTab(QWidget):
 
         self.connection = None  # assigne par les sous-classes
         self._log_file = None
+        self._connection_generation = 0
+        self._closing = False
 
     # ---------- journalisation ----------
     def toggle_logging(self) -> None:
@@ -147,20 +150,34 @@ class BaseTerminalTab(QWidget):
             self.stop_logging()
 
     def _wire_connection(self) -> None:
-        self.connection.connected.connect(self._on_connected)
+        # Un signal deconnexion/erreur/connexion emis par une connexion remplacee
+        # entre-temps (ex. reconnexion en cours) ne doit pas ecraser l'etat de la
+        # nouvelle : chaque connexion est associee a la generation en cours au
+        # moment ou elle est cablee, et un signal d'une generation perimee est ignore.
+        generation = self._connection_generation
+        self.connection.connected.connect(lambda: self._on_current_generation(generation, self._on_connected))
         self.connection.data_received.connect(self.terminal.feed)
         self.connection.data_received.connect(self._log_output)
-        self.connection.disconnected.connect(self._on_disconnected)
-        self.connection.error.connect(self._on_error)
+        self.connection.disconnected.connect(
+            lambda reason: self._on_current_generation(generation, self._on_disconnected, reason)
+        )
+        self.connection.error.connect(
+            lambda message: self._on_current_generation(generation, self._on_error, message)
+        )
         self.terminal.data_to_send.connect(self.connection.send)
         self.terminal.resized.connect(self.connection.resize)
 
+    def _on_current_generation(self, generation: int, fn, *args) -> None:
+        if generation == self._connection_generation:
+            fn(*args)
+
     def _create_connection(self):
         """Fabrique la connexion. Redefinie par chaque sous-classe : c'est ce qui
         permet de la recreer a l'identique lors d'une reconnexion."""
         raise NotImplementedError
 
     def start_connection(self) -> None:
+        self._connection_generation += 1
         self.connection = self._create_connection()
         self._wire_connection()
         self.connection.start()
@@ -206,6 +223,7 @@ class BaseTerminalTab(QWidget):
         self.search_status.setText("" if found else "aucun resultat")
 
     def close_connection(self) -> None:
+        self._closing = True  # ne jamais reconnecter automatiquement une fermeture voulue
         self.stop_logging()
         if self.connection:
             self.connection.close_connection()
@@ -244,6 +262,19 @@ class SessionTabWidget(BaseTerminalTab):
 
         self._secret = secret
         self.sftp_toggle.toggled.connect(self._toggle_sftp)
+
+        # Reconnexion automatique : un timer a declenchement unique pour la
+        # reconnexion elle-meme, et un second pour rafraichir le compte a
+        # rebours affiche a l'utilisateur pendant l'attente.
+        self._reconnect_attempt = 0
+        self._reconnect_seconds_left = 0
+        self._reconnect_last_reason = ""
+        self._reconnect_timer = QTimer(self)
+        self._reconnect_timer.setSingleShot(True)
+        self._reconnect_timer.timeout.connect(self._do_reconnect)
+        self._reconnect_countdown_timer = QTimer(self)
+        self._reconnect_countdown_timer.timeout.connect(self._tick_reconnect_countdown)
+
         self.start_connection()
 
     def _create_connection(self):
@@ -261,6 +292,9 @@ class SessionTabWidget(BaseTerminalTab):
             open_sftp_on_connect=True,
             bastion_target=self._bastion_target,
             bastion_password=self._bastion_password,
+            keepalive_enabled=session.keepalive_enabled,
+            keepalive_interval=session.keepalive_interval,
+            keepalive_count_max=session.keepalive_count_max,
         )
         connection.sftp_ready.connect(self._on_sftp_ready)
         connection.password_prompt.connect(self._on_password_prompt)
@@ -278,6 +312,7 @@ class SessionTabWidget(BaseTerminalTab):
         self.tunnel_btn.setText(f"🔀 Tunnels ({actifs})" if actifs else "🔀 Tunnels")
 
     def _on_connected(self) -> None:
+        self._reconnect_attempt = 0  # une connexion reussie remet le compteur a zero
         self.status_label.setText(f"● Connecte : {self.session.username}@{self.session.host}:{self.session.port}")
         transport = self.connection.client.get_transport() if self.connection.client else None
         if transport:
@@ -290,6 +325,57 @@ class SessionTabWidget(BaseTerminalTab):
     def _on_disconnected(self, reason: str) -> None:
         super()._on_disconnected(reason)
         self.sftp_toggle.setEnabled(False)
+        self._maybe_schedule_reconnect(reason)
+
+    def reconnect(self) -> None:
+        self._cancel_reconnect_timers()
+        super().reconnect()
+
+    # ---------- reconnexion automatique ----------
+    def _cancel_reconnect_timers(self) -> None:
+        self._reconnect_timer.stop()
+        self._reconnect_countdown_timer.stop()
+
+    def _maybe_schedule_reconnect(self, reason: str) -> None:
+        if self._closing or not self.session.reconnect_enabled:
+            return
+        max_attempts = self.session.reconnect_max_attempts
+        self._reconnect_attempt += 1
+        if max_attempts and self._reconnect_attempt > max_attempts:
+            self.status_label.setText(
+                f"● Deconnecte ({reason}). Abandon apres {max_attempts} tentative(s) de reconnexion."
+            )
+            self.reconnect_btn.show()
+            return
+        self._reconnect_last_reason = reason
+        self._reconnect_seconds_left = compute_backoff_delay(
+            self._reconnect_attempt, self.session.reconnect_initial_delay,
+        )
+        self._update_reconnect_status()
+        self._reconnect_countdown_timer.start(1000)
+        self._reconnect_timer.start(self._reconnect_seconds_left * 1000)
+
+    def _tick_reconnect_countdown(self) -> None:
+        self._reconnect_seconds_left -= 1
+        if self._reconnect_seconds_left <= 0:
+            self._reconnect_countdown_timer.stop()
+            return
+        self._update_reconnect_status()
+
+    def _update_reconnect_status(self) -> None:
+        max_attempts = self.session.reconnect_max_attempts
+        total = f"/{max_attempts}" if max_attempts else ""
+        self.status_label.setText(
+            f"● Connexion perdue ({self._reconnect_last_reason}). "
+            f"Reconnexion dans {self._reconnect_seconds_left} seconde(s)... "
+            f"(Tentative {self._reconnect_attempt}{total})"
+        )
+
+    def _do_reconnect(self) -> None:
+        self._reconnect_countdown_timer.stop()
+        if self._closing:
+            return
+        self.reconnect()
 
     def _on_host_key_prompt(self, hostname: str, key_type: str, fingerprint: str) -> None:
         accepted = confirm_host_key(self, hostname, key_type, fingerprint)
@@ -326,6 +412,7 @@ class SessionTabWidget(BaseTerminalTab):
         return paramiko.SFTPClient.from_transport(self.connection.client.get_transport())
 
     def close_connection(self) -> None:
+        self._cancel_reconnect_timers()
         if self.sftp_panel:
             self.sftp_panel.shutdown()
         if self.tunnel_manager:
@@ -380,6 +467,9 @@ class SFTPTabWidget(QWidget):
             open_sftp_on_connect=True,
             bastion_target=bastion_target,
             bastion_password=bastion_password,
+            keepalive_enabled=session.keepalive_enabled,
+            keepalive_interval=session.keepalive_interval,
+            keepalive_count_max=session.keepalive_count_max,
         )
         self.connection.sftp_ready.connect(self._on_sftp_ready)
         self.connection.password_prompt.connect(self._on_password_prompt)