c08037a638
Support minimum : Host, HostName, User, Port, IdentityFile, ProxyJump, ForwardAgent, ServerAliveInterval, ServerAliveCountMax. - app/openssh/config.py : load_openssh_hosts() lit ~/.ssh/config via paramiko.SSHConfig (gere nativement les blocs "Host *" fusionnes, les alias multiples sur une meme ligne Host, et l'expansion ~ des IdentityFile). Fichier absent = liste vide, pas une erreur. session_from_openssh_host() convertit un Host en Session PySSH (groupe "OpenSSH", cle si IdentityFile presente sinon authentification auto). - Nouvelle section "Configuration OpenSSH" dans le panneau lateral (SessionController), sous Sessions SSH : double-clic ou menu contextuel pour se connecter directement ou importer comme session (editeur pre-rempli, ajustable avant enregistrement) ; rafraichissement via le menu ⚙ ou le menu contextuel de l'hote. - ConnectionController.open_openssh_host() ouvre une connexion directe sans enregistrer de session, comme une connexion rapide. Le ProxyJump est detecte, affiche (badge "· via <bastion>", tooltip) et reporte dans les notes d'une session importee, mais pas encore applique automatiquement a la connexion : ce sera l'objet de la Phase 3 (Bastion / Jump Host), qui prendra en charge toutes ses sources (OpenSSH, session PySSH, config manuelle) via un mecanisme commun. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
203 lines
8.6 KiB
Python
203 lines
8.6 KiB
Python
"""Fenetre principale : assemble le panneau des sessions, les onglets, les menus.
|
|
|
|
La logique metier vit dans des controleurs dedies (app.controllers) et les widgets
|
|
d'onglet dans app.ui.tabs ; cette classe se contente de les construire et de les
|
|
relier.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
from PySide6.QtCore import Qt
|
|
from PySide6.QtGui import QAction, QActionGroup, QKeySequence
|
|
from PySide6.QtWidgets import (
|
|
QMainWindow, QDockWidget, QMessageBox, QStatusBar, QApplication,
|
|
)
|
|
|
|
from app.session_manager import SessionStore
|
|
from app.key_manager import KeyManager
|
|
from app.local_terminal import SHELL_LABELS, DEFAULT_SHELL
|
|
from app.terminal_widget import TerminalWidget
|
|
from app.dialogs.key_dialog import KeyManagerDialog
|
|
from app.dialogs.known_hosts_dialog import KnownHostsDialog
|
|
from app.theme import THEME_LABELS, apply_theme, current_theme, save_theme
|
|
from app.controllers.broadcast_manager import BroadcastManager
|
|
from app.controllers.session_controller import SessionController
|
|
from app.controllers.connection_controller import ConnectionController
|
|
|
|
# re-exporte pour compatibilite (utilise par tests/test_detect.py et du code existant)
|
|
from app.services.ssh_target import detect_ssh_target # noqa: F401
|
|
|
|
|
|
class MainWindow(QMainWindow):
|
|
def __init__(self):
|
|
super().__init__()
|
|
self.setWindowTitle("PySSH Client")
|
|
self.resize(1280, 820)
|
|
|
|
self.session_store = SessionStore()
|
|
self.key_manager = KeyManager()
|
|
|
|
self.broadcast = BroadcastManager(self._iter_tabs, self)
|
|
self.connection_controller = ConnectionController(
|
|
self.session_store, self.key_manager, self.broadcast, parent_widget=self,
|
|
)
|
|
self.session_controller = SessionController(
|
|
self.session_store, self.key_manager, self.broadcast.button, parent_widget=self,
|
|
)
|
|
self._wire_controllers()
|
|
|
|
self._build_menu()
|
|
self._build_sidebar()
|
|
self.setCentralWidget(self.connection_controller.tabs)
|
|
self.setStatusBar(QStatusBar())
|
|
|
|
# demarre directement dans un terminal utilisable, sans avoir a en choisir un
|
|
self.connection_controller.open_local_terminal(DEFAULT_SHELL)
|
|
|
|
# ---------- acces retro-compatible (tests, code externe) ----------
|
|
@property
|
|
def tabs(self):
|
|
return self.connection_controller.tabs
|
|
|
|
def _iter_tabs(self):
|
|
tabs = self.connection_controller.tabs
|
|
return [tabs.widget(i) for i in range(tabs.count())]
|
|
|
|
# ---------- cablage entre controleurs ----------
|
|
def _wire_controllers(self) -> None:
|
|
sc, cc = self.session_controller, self.connection_controller
|
|
sc.open_session_requested.connect(cc.open_session)
|
|
sc.open_sftp_requested.connect(cc.open_sftp_session)
|
|
sc.open_local_shell_requested.connect(cc.open_local_terminal)
|
|
sc.open_openssh_host_requested.connect(cc.open_openssh_host)
|
|
sc.quick_sftp_requested.connect(cc.quick_sftp)
|
|
sc.manage_keys_requested.connect(self.open_key_manager)
|
|
sc.manage_known_hosts_requested.connect(self.open_known_hosts_manager)
|
|
cc.session_saved.connect(sc.reload)
|
|
|
|
# ---------- construction UI ----------
|
|
def _build_menu(self) -> None:
|
|
file_menu = self.menuBar().addMenu("&Fichier")
|
|
new_session_action = QAction("Nouvelle session...", self)
|
|
new_session_action.setShortcut(QKeySequence("Ctrl+N"))
|
|
new_session_action.triggered.connect(self.session_controller.new_session)
|
|
file_menu.addAction(new_session_action)
|
|
|
|
file_menu.addSeparator()
|
|
|
|
quick_ssh_action = QAction("Connexion SSH rapide...", self)
|
|
quick_ssh_action.setShortcut(QKeySequence("Ctrl+Shift+S"))
|
|
quick_ssh_action.triggered.connect(self.connection_controller.quick_ssh)
|
|
file_menu.addAction(quick_ssh_action)
|
|
|
|
quick_sftp_action = QAction("Connexion SFTP (gestionnaire de fichiers)...", self)
|
|
quick_sftp_action.setShortcut(QKeySequence("Ctrl+Shift+F"))
|
|
quick_sftp_action.triggered.connect(self.connection_controller.quick_sftp)
|
|
file_menu.addAction(quick_sftp_action)
|
|
|
|
file_menu.addSeparator()
|
|
|
|
default_action = QAction(
|
|
f"Nouveau terminal local ({SHELL_LABELS.get(DEFAULT_SHELL, DEFAULT_SHELL)})", self
|
|
)
|
|
default_action.setShortcut(QKeySequence("Ctrl+Shift+T"))
|
|
default_action.triggered.connect(lambda: self.connection_controller.open_local_terminal(DEFAULT_SHELL))
|
|
file_menu.addAction(default_action)
|
|
|
|
others_menu = file_menu.addMenu("Autre terminal local")
|
|
for shell_id, label in SHELL_LABELS.items():
|
|
others_menu.addAction(label, lambda s=shell_id: self.connection_controller.open_local_terminal(s))
|
|
|
|
file_menu.addSeparator()
|
|
quit_action = QAction("Quitter", self)
|
|
quit_action.triggered.connect(self.close)
|
|
file_menu.addAction(quit_action)
|
|
|
|
keys_menu = self.menuBar().addMenu("&Cles SSH")
|
|
manage_keys_action = QAction("Gestionnaire de cles...", self)
|
|
manage_keys_action.triggered.connect(self.open_key_manager)
|
|
keys_menu.addAction(manage_keys_action)
|
|
|
|
view_menu = self.menuBar().addMenu("&Affichage")
|
|
|
|
self.toggle_sidebar_action = QAction("Panneau des sessions", self, checkable=True)
|
|
self.toggle_sidebar_action.setChecked(True)
|
|
self.toggle_sidebar_action.setShortcut(QKeySequence("F9"))
|
|
self.toggle_sidebar_action.triggered.connect(self.toggle_sidebar)
|
|
view_menu.addAction(self.toggle_sidebar_action)
|
|
view_menu.addSeparator()
|
|
|
|
theme_menu = view_menu.addMenu("Theme")
|
|
self.theme_group = QActionGroup(self)
|
|
self.theme_group.setExclusive(True)
|
|
for theme_id, label in THEME_LABELS.items():
|
|
action = QAction(label, self, checkable=True)
|
|
action.setChecked(theme_id == current_theme())
|
|
action.triggered.connect(lambda _checked=False, t=theme_id: self.change_theme(t))
|
|
self.theme_group.addAction(action)
|
|
theme_menu.addAction(action)
|
|
|
|
hosts_menu = self.menuBar().addMenu("&Hotes connus")
|
|
manage_hosts_action = QAction("Gestionnaire des hotes connus...", self)
|
|
manage_hosts_action.triggered.connect(self.open_known_hosts_manager)
|
|
hosts_menu.addAction(manage_hosts_action)
|
|
|
|
help_menu = self.menuBar().addMenu("&Aide")
|
|
about_action = QAction("A propos", self)
|
|
about_action.triggered.connect(self.show_about)
|
|
help_menu.addAction(about_action)
|
|
|
|
def _build_sidebar(self) -> None:
|
|
dock = QDockWidget("Sessions", self)
|
|
# Closable : sans cette option, le panneau n'a pas de bouton de fermeture
|
|
# et ne peut pas etre masque.
|
|
dock.setFeatures(
|
|
QDockWidget.DockWidgetMovable
|
|
| QDockWidget.DockWidgetFloatable
|
|
| QDockWidget.DockWidgetClosable
|
|
)
|
|
self.sessions_dock = dock
|
|
|
|
dock.setWidget(self.session_controller.widget)
|
|
self.addDockWidget(Qt.LeftDockWidgetArea, dock)
|
|
self.resizeDocks([dock], [300], Qt.Horizontal)
|
|
# garde la case du menu Affichage synchronisee si on ferme le panneau par sa croix
|
|
dock.visibilityChanged.connect(self.toggle_sidebar_action.setChecked)
|
|
|
|
# ---------- cles / affichage / a propos ----------
|
|
def toggle_sidebar(self, visible: bool | None = None) -> None:
|
|
"""Affiche ou masque le panneau des sessions (F9)."""
|
|
if visible is None:
|
|
visible = not self.sessions_dock.isVisible()
|
|
self.sessions_dock.setVisible(visible)
|
|
self.toggle_sidebar_action.setChecked(visible)
|
|
|
|
def change_theme(self, theme: str) -> None:
|
|
"""Applique un theme a chaud : feuille de style de l'interface + couleurs des
|
|
terminaux deja ouverts (qui ont leur propre palette, hors QSS)."""
|
|
app = QApplication.instance()
|
|
if app is None:
|
|
return
|
|
apply_theme(app, theme)
|
|
save_theme(theme)
|
|
for widget in self.findChildren(TerminalWidget):
|
|
widget.refresh_theme()
|
|
|
|
def open_key_manager(self) -> None:
|
|
dialog = KeyManagerDialog(self.key_manager, parent=self)
|
|
dialog.exec()
|
|
|
|
def open_known_hosts_manager(self) -> None:
|
|
dialog = KnownHostsDialog(parent=self)
|
|
dialog.exec()
|
|
|
|
def show_about(self) -> None:
|
|
QMessageBox.information(
|
|
self, "A propos",
|
|
"PySSH Client\n\nClient SSH/SFTP local avec gestion de sessions, de cles, "
|
|
"et terminaux locaux integres.\nBase sur PySide6, paramiko, pywinpty et pyte.",
|
|
)
|
|
|
|
def closeEvent(self, event) -> None:
|
|
self.connection_controller.close_all()
|
|
super().closeEvent(event)
|