pyssh-client/README.md

# PySSH Client

Client SSH/SFTP personnel (type MobaXterm/Termius/Bitvise), 100% local, sans compte ni service tiers.

## Fonctionnalites

- Sessions SSH multiples dans des onglets, avec terminal ANSI colore et trois themes
- Copier-coller dans le terminal : selection a la souris, double-clic pour selectionner un mot,
  `Ctrl+Shift+C` / `Ctrl+Shift+V`, `Maj+Inser`, clic molette, et menu au clic droit.
  `Ctrl+C` reste l'interruption, comme dans tout terminal
- Confort d'affichage : zoom `Ctrl+molette` ou `Ctrl+ +/-` (`Ctrl+0` remet a zero, la taille est
  memorisee), barre de defilement de l'historique, `Maj+PagePrec/Suiv`, `Ctrl+Fin` pour revenir
  en direct, et recherche dans l'historique avec `Ctrl+F`
- Reconnexion en un clic quand une session tombe (bouton dans la barre de l'onglet) : pratique
  avec des serveurs de test qui redemarrent souvent
- Les hotes deja approuves par votre commande `ssh` (`~/.ssh/known_hosts`) sont reconnus : pas de
  double confirmation d'empreinte. Les nouvelles cles vont dans le fichier propre a l'application
- Terminaux locaux Windows (PowerShell / Invite de commandes) accessibles en un clic, **sans avoir besoin d'une session enregistree** — pratique pour un usage ponctuel, comme le terminal Windows natif
- Carnet d'adresses de serveurs (JSON local, `data/sessions.json`) organise par dossiers, connexion en un clic
- Gestion des cles SSH : generation (Ed25519 / RSA), import de cles existantes, export (cle publique/privee)
- Client SFTP integre facon WinSCP : double panneau local/distant avec colonnes triables (nom, taille, date, droits),
  glisser-deposer entre les panneaux, renommage (F2), suppression (Suppr), creation de dossier, permissions distantes
  (chmod), et file de transferts avec progression. **Aucun favori n'est necessaire pour l'utiliser** — voir ci-dessous
- **SFTP sur la connexion en cours** : depuis n'importe quel terminal ou vous avez tape `ssh user@hote` a la main, le
  bouton "📁 SFTP sur cette connexion" lit l'hote, l'utilisateur et le port dans la commande saisie et ouvre le
  gestionnaire de fichiers dessus. Pense pour les serveurs de test en DHCP, qu'on n'a aucune envie d'enregistrer
- **Authentification automatique** (mode par defaut) : comme la commande `ssh`, l'application utilise l'agent SSH et les
  cles de `~/.ssh` sans que vous ayez a designer quoi que ce soit, et ne demande un mot de passe qu'en dernier recours
- Verification des empreintes de cles d'hote (TOFU) avant premiere connexion, comme un client SSH classique
- Gestionnaire des hotes connus (menu "Hotes connus" ou bouton "⚙" du panneau lateral) : si une adresse en DHCP change de machine, la cle d'hote presentee ne correspond plus a celle enregistree — l'application le detecte et propose de remplacer l'ancienne entree directement au moment de la connexion, sans avoir a vider le fichier `known_hosts` a la main. Le gestionnaire permet aussi un nettoyage manuel (par hote ou en une fois).

Aucun mot de passe n'est stocke sur le disque : l'authentification par mot de passe est demandee a chaque connexion, et les passphrases de cles sont demandees uniquement en memoire au moment de la connexion.

## Installation (Windows)

Necessite Python 3.10+ installe sur le poste (verifiable avec `py -3 --version`).

```bash
setup.bat
```

Ce script cree un environnement virtuel local (`venv/`) et y installe les dependances (PySide6, paramiko, pyte, cryptography, pywinpty) — rien n'est installe globalement sur le poste.

## Lancement

Trois facons, au choix :

- **Raccourci Windows** (recommande) : double-cliquez sur `PySSH Client.lnk` a la racine du projet.
  Il lance l'application via `pythonw.exe`, donc **sans fenetre de console noire**. Vous pouvez le
  copier sur le Bureau, ou l'epingler a la barre des taches.
  Pour le (re)creer — apres un deplacement du projet, ou sur un autre poste :

  ```bash
  powershell -ExecutionPolicy Bypass -File tools\create_shortcut.ps1 -Desktop
  ```

  (`-Desktop` et `-StartMenu` sont optionnels et ajoutent une copie a ces emplacements.)

- **En ligne de commande**, sans console residuelle :

  ```bash
  venv\Scripts\pythonw.exe main.py
  ```

- **`run.bat`** : garde une fenetre de console ouverte, ce qui est pratique pour voir les erreurs
  si l'application refuse de demarrer.

## Version portable (sans Python installe)

```bash
build_exe.bat
```

Produit un dossier autonome `dist\PySSH Client\` contenant l'executable et tout ce dont il a besoin,
interpreteur Python compris. Copiez ce dossier ou vous voulez (y compris sur une cle USB) : il
fonctionne sur n'importe quel poste Windows, **meme sans Python installe**.

Le format retenu est un dossier plutot qu'un fichier `.exe` unique : avec PySide6, un executable
unique doit decompresser environ 200 Mo a chaque lancement, ce qui ajoute plusieurs secondes
d'attente a chaque demarrage. Le dossier demarre immediatement.

> **Note pour qui modifie la recette de build** (`PySSHClient.spec`) : `pywinpty` a besoin de deux
> executables auxiliaires, `OpenConsole.exe` (backend ConPTY) et `winpty-agent.exe` (repli WinPTY).
> PyInstaller ne suit que les DLL liees et les oublie : ils sont donc ajoutes explicitement dans
> `datas`. Sans eux, l'application se lance normalement mais **tous les terminaux se ferment
> instantanement** ("Deconnecte (Terminal ferme)").

**Ou sont stockees les donnees ?** A cote de l'executable, dans son propre sous-dossier `data\`
(mode portable : vos sessions et cles suivent la cle USB). Si cet emplacement n'est pas accessible
en ecriture — installation dans `Program Files`, support en lecture seule — l'application bascule
automatiquement sur `%APPDATA%\PySSHClient\`.

## Premiers pas

1. **Terminal local immediat** : bouton "💻 Terminal" dans le panneau lateral (ou `Ctrl+Shift+T`), ou double-clic sur "PowerShell"/"Invite de commandes" dans la section "Terminaux locaux" de l'arborescence — aucune session a creer.
2. **Nouvelle session SSH** (bouton "+ Session" ou `Ctrl+N`) : renseignez l'hote, le port, l'utilisateur et le mode d'authentification.
3. **Cles SSH** (menu "Cles SSH > Gestionnaire de cles") : generez une nouvelle paire de cles ou importez-en une existante, puis selectionnez-la dans le formulaire de session.
4. Double-cliquez sur une session dans l'arborescence pour ouvrir un onglet terminal SSH.
5. **SFTP — trois facons d'y arriver**, selon la situation :
   - *Vous avez tape `ssh user@hote` dans un terminal* : bouton **"📁 SFTP sur cette connexion"** dans la barre de
     l'onglet. L'hote et l'utilisateur sont deduits de la commande, le formulaire est pre-rempli. Rien a enregistrer.
   - *Connexion ponctuelle* : bouton **"📁 SFTP"** du panneau lateral, ou `Ctrl+Shift+F`. La case "Enregistrer dans mes
     sessions" est decochee par defaut.
   - *Session enregistree* : clic droit > **"Ouvrir en SFTP"** (onglet dedie). Dans une session SSH ouverte par
     l'application, le panneau de fichiers est deja affiche a cote du terminal, comme dans MobaXterm.

   Dans tous les cas : glisser-deposer entre les deux panneaux, F2 renomme, Suppr supprime, F5 actualise, et le clic
   droit sur le panneau distant donne acces aux permissions (chmod).

## Structure du projet

```
main.py                    point d'entree
app/
  theme.py                  feuille de style "bleu nuit" + icone d'application
  session_manager.py       base de sessions (JSON)
  key_manager.py           generation/import/export de cles SSH
  ssh_connection.py        connexion SSH en arriere-plan (paramiko + QThread)
  known_hosts_manager.py   gestion du fichier known_hosts (lister/retirer/remplacer une cle d'hote)
  local_terminal.py         terminal local Windows (PowerShell/cmd via pywinpty)
  terminal_widget.py       emulateur de terminal ANSI (pyte + QPainter)
  sftp_panel.py             client SFTP a deux panneaux
  main_window.py            fenetre principale (arbre de sessions + onglets)
  dialogs/                  boites de dialogue (session, cles, connexion)
resources/
  theme.qss                  feuille de style Qt "bleu nuit"
data/
  sessions.json             vos serveurs enregistres (non versionne)
  keys.json                 registre des cles connues (non versionne)
  keys/                      cles generees par l'application (non versionne)
  known_hosts                empreintes d'hotes approuvees (non versionne)
```

## Tests

```bash
tests\run_all.bat
```

Les tests construisent de vraies fenetres Qt sans les afficher (`QT_QPA_PLATFORM=offscreen`) et
couvrent : le copier-coller et les raccourcis du terminal, la detection de l'hote dans une commande
`ssh` tapee a la main, la logique SFTP (transferts, renommage, tri, suppression recursive) avec un
serveur simule, et la construction complete de l'application.

## Limites connues / pistes d'amelioration

- L'emulation de terminal couvre les usages courants (bash, vim, htop...) mais n'est pas un xterm parfaitement complet.
- Le terminal local repose sur `pywinpty` (pseudo-console Windows). Si un onglet local reste bloque sur un ecran vide, tapez une touche : le rafraichissement de la console Windows peut etre paresseux dans certains contextes (notamment les sessions Windows non interactives) et se declenche a la premiere frappe.
- Le SFTP ne propose pas encore l'edition de fichier distant en place (telecharger / modifier / renvoyer a la main).
- Pas encore d'export/import global du carnet de sessions (le fichier `data/sessions.json` peut etre copie manuellement).