graphical-ssh 0.1.1__py3-none-any.whl

gssh/main_window.py

@@ -0,0 +1,384 @@
+"""Main application window — host list, editor, and connection management."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from PyQt6.QtCore import Qt, QThread, pyqtSignal
+from PyQt6.QtWidgets import (
+    QDockWidget,
+    QHBoxLayout,
+    QLabel,
+    QLineEdit,
+    QListWidget,
+    QListWidgetItem,
+    QMainWindow,
+    QMessageBox,
+    QPushButton,
+    QSplitter,
+    QTableView,
+    QToolBar,
+    QVBoxLayout,
+    QWidget,
+)
+
+from .config import HostEntry, SSHConfig, load_config, save_config
+from .connect import build_ssh_command, launch_external, launch_in_app, test_connection
+from .host_editor import HostEditorDialog
+from .linter import LintFinding, lint_config, severity_icon
+from .models import HostTableModel
+
+
+class _ConnectionTestWorker(QThread):
+    """Runs a connection test in a background thread."""
+
+    finished = pyqtSignal(object, object)  # (host_alias, ConnectionTestResult)
+
+    def __init__(self, host: HostEntry, parent=None) -> None:
+        super().__init__(parent)
+        self._host = host
+
+    def run(self) -> None:
+        result = test_connection(self._host)
+        self.finished.emit(self._host.alias, result)
+
+
+class MainWindow(QMainWindow):
+    """The main gssh window."""
+
+    def __init__(self, config_path: Path | None = None) -> None:
+        super().__init__()
+        self.setWindowTitle("gssh — SSH Connection Manager")
+        self.setMinimumSize(900, 600)
+
+        self._config_path = config_path
+        self._config: SSHConfig = SSHConfig()
+        self._terminal_widget = None  # type: ignore
+        self._test_worker = None  # type: ignore
+        self._lint_findings: list[LintFinding] = []
+
+        self._build_ui()
+        self._load_config()
+
+    def _build_ui(self) -> None:
+        # Central widget: splitter with host table (left) and terminal area (right)
+        central = QWidget()
+        layout = QVBoxLayout(central)
+        layout.setContentsMargins(0, 0, 0, 0)
+
+        splitter = QSplitter(Qt.Orientation.Horizontal)
+
+        # Left: host table
+        left_panel = QWidget()
+        left_layout = QVBoxLayout(left_panel)
+        left_layout.setContentsMargins(4, 4, 4, 4)
+
+        # Search bar
+        search_layout = QHBoxLayout()
+        self.search_edit = QLineEdit()
+        self.search_edit.setPlaceholderText("Filter hosts…")
+        self.search_edit.textChanged.connect(self._filter_hosts)
+        search_layout.addWidget(self.search_edit)
+        left_layout.addLayout(search_layout)
+
+        # Table
+        self.table_model = HostTableModel()
+        self.table = QTableView()
+        self.table.setModel(self.table_model)
+        self.table.setSelectionBehavior(QTableView.SelectionBehavior.SelectRows)
+        self.table.setSelectionMode(QTableView.SelectionMode.SingleSelection)
+        self.table.setAlternatingRowColors(True)
+        self.table.doubleClicked.connect(self._on_connect)
+        left_layout.addWidget(self.table)
+
+        splitter.addWidget(left_panel)
+
+        # Right: terminal container (starts empty)
+        self.terminal_container = QWidget()
+        self.terminal_layout = QVBoxLayout(self.terminal_container)
+        self.terminal_layout.setContentsMargins(0, 0, 0, 0)
+        self.terminal_placeholder = QLabel("Select a host and click Connect to open a terminal session.")
+        self.terminal_placeholder.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        self.terminal_placeholder.setStyleSheet("color: #888; font-size: 14px;")
+        self.terminal_layout.addWidget(self.terminal_placeholder)
+        splitter.addWidget(self.terminal_container)
+
+        splitter.setSizes([350, 550])
+        layout.addWidget(splitter)
+        self.setCentralWidget(central)
+
+        # Toolbar
+        self._build_toolbar()
+
+        # Lint dock widget
+        self._lint_dock = QDockWidget("Config Warnings", self)
+        self._lint_dock.setAllowedAreas(Qt.DockWidgetArea.BottomDockWidgetArea)
+        self._lint_list = QListWidget()
+        self._lint_list.itemClicked.connect(self._on_lint_item_clicked)
+        self._lint_dock.setWidget(self._lint_list)
+        self.addDockWidget(Qt.DockWidgetArea.BottomDockWidgetArea, self._lint_dock)
+        self._lint_dock.hide()
+
+        # Status bar
+        self.statusBar().showMessage("Ready")
+
+    def _build_toolbar(self) -> None:
+        toolbar = QToolBar("Main")
+        toolbar.setMovable(False)
+        self.addToolBar(toolbar)
+
+        btn_add = QPushButton("Add Host")
+        btn_add.clicked.connect(self._on_add_host)
+        toolbar.addWidget(btn_add)
+
+        btn_edit = QPushButton("Edit")
+        btn_edit.clicked.connect(self._on_edit_host)
+        toolbar.addWidget(btn_edit)
+
+        btn_delete = QPushButton("Delete")
+        btn_delete.clicked.connect(self._on_delete_host)
+        toolbar.addWidget(btn_delete)
+
+        toolbar.addSeparator()
+
+        self.btn_connect = QPushButton("Connect")
+        self.btn_connect.clicked.connect(self._on_connect_clicked)
+        toolbar.addWidget(self.btn_connect)
+
+        btn_test = QPushButton("Test")
+        btn_test.clicked.connect(self._on_test_connection)
+        toolbar.addWidget(btn_test)
+
+        toolbar.addSeparator()
+
+        # Terminal mode toggle
+        self.btn_inapp = QPushButton("In-App Terminal")
+        self.btn_inapp.setCheckable(True)
+        self.btn_inapp.setChecked(True)
+        self.btn_inapp.setToolTip("Toggle: use in-app terminal or launch external terminal")
+        self.btn_inapp.clicked.connect(self._on_toggle_mode)
+        toolbar.addWidget(self.btn_inapp)
+
+        toolbar.addSeparator()
+
+        btn_reload = QPushButton("Reload")
+        btn_reload.clicked.connect(self._load_config)
+        toolbar.addWidget(btn_reload)
+
+        btn_save = QPushButton("Save")
+        btn_save.clicked.connect(self._on_save)
+        toolbar.addWidget(btn_save)
+
+    def _load_config(self) -> None:
+        try:
+            self._config = load_config(self._config_path)
+            self.table_model.set_hosts(list(self._config.hosts))
+            self.statusBar().showMessage(f"Loaded {len(self._config.hosts)} hosts from {self._config_path or '~/.ssh/config'}")
+            self._run_linter()
+        except Exception as e:
+            QMessageBox.critical(self, "Error", f"Failed to load SSH config:\n{e}")
+
+    def _run_linter(self) -> None:
+        """Run the config linter and populate the warnings dock."""
+        findings = lint_config(self._config, self._config_path)
+        self._lint_findings = findings
+        self._lint_list.clear()
+        if not findings:
+            self._lint_dock.hide()
+            return
+        for f in findings:
+            item = QListWidgetItem(f"{severity_icon(f.severity)}  {f.host_alias}: {f.message}")
+            item.setToolTip(f.suggestion or f.message)
+            if f.severity == "error":
+                item.setForeground(Qt.GlobalColor.red)
+            elif f.severity == "warning":
+                item.setForeground(Qt.GlobalColor.darkYellow)
+            self._lint_list.addItem(item)
+        self._lint_dock.show()
+        self.statusBar().showMessage(f"{len(findings)} config warning(s) found.", 5000)
+
+    def _on_lint_item_clicked(self, item: QListWidgetItem) -> None:
+        """Jump to the host referenced by a lint finding."""
+        row = self._lint_list.row(item)
+        if 0 <= row < len(self._lint_findings):
+            finding = self._lint_findings[row]
+            for i, host in enumerate(self.table_model.hosts):
+                if host.alias == finding.host_alias:
+                    self.table.selectRow(i)
+                    break
+
+    def _filter_hosts(self) -> None:
+        query = self.search_edit.text().lower().strip()
+        if not query:
+            self.table_model.set_hosts(list(self._config.hosts))
+        else:
+            filtered = [
+                h for h in self._config.hosts
+                if query in h.alias.lower()
+                or query in h.hostname.lower()
+                or query in h.user.lower()
+            ]
+            self.table_model.set_hosts(filtered)
+
+    def _selected_row(self) -> int:
+        idx = self.table.currentIndex()
+        return idx.row() if idx.isValid() else -1
+
+    def _on_add_host(self) -> None:
+        dlg = HostEditorDialog(parent=self)
+        if dlg.exec() == HostEditorDialog.DialogCode.Accepted:
+            host = dlg.result_host()
+            self._config.hosts.append(host)
+            self.table_model.set_hosts(list(self._config.hosts))
+            self.statusBar().showMessage(f"Added host '{host.alias}'. Remember to Save.")
+
+    def _on_edit_host(self) -> None:
+        row = self._selected_row()
+        if row < 0:
+            return
+        host = self.table_model.get_host(row)
+        if host is None:
+            return
+        dlg = HostEditorDialog(host=host, parent=self)
+        if dlg.exec() == HostEditorDialog.DialogCode.Accepted:
+            updated = dlg.result_host()
+            # Update in config — find by original alias
+            orig_alias = host.alias
+            for i, h in enumerate(self._config.hosts):
+                if h.alias == orig_alias:
+                    self._config.hosts[i] = updated
+                    break
+            self.table_model.set_hosts(list(self._config.hosts))
+            self.statusBar().showMessage(f"Updated host '{updated.alias}'. Remember to Save.")
+
+    def _on_delete_host(self) -> None:
+        row = self._selected_row()
+        if row < 0:
+            return
+        host = self.table_model.get_host(row)
+        if host is None:
+            return
+        reply = QMessageBox.question(
+            self, "Delete Host",
+            f"Remove host '{host.alias}' from your SSH config?\n(This takes effect after Save.)",
+            QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
+        )
+        if reply == QMessageBox.StandardButton.Yes:
+            orig_alias = host.alias
+            self._config.hosts = [h for h in self._config.hosts if h.alias != orig_alias]
+            self.table_model.set_hosts(list(self._config.hosts))
+            self.statusBar().showMessage(f"Deleted host '{host.alias}'. Remember to Save.")
+
+    def _on_connect_clicked(self) -> None:
+        if self._terminal_widget is not None:
+            self._disconnect()
+        else:
+            self._on_connect()
+
+    def _disconnect(self) -> None:
+        if self._terminal_widget is not None:
+            self._terminal_widget.stop()
+            self.terminal_layout.removeWidget(self._terminal_widget)
+            self._terminal_widget.deleteLater()
+            self._terminal_widget = None
+        self.terminal_placeholder.show()
+        self.btn_connect.setText("Connect")
+        self.statusBar().showMessage("Disconnected.")
+
+    def _on_connect(self) -> None:
+        row = self._selected_row()
+        if row < 0:
+            QMessageBox.information(self, "Connect", "Select a host first.")
+            return
+        host = self.table_model.get_host(row)
+        if host is None:
+            return
+
+        cmd = build_ssh_command(host)
+        if not cmd:
+            QMessageBox.warning(self, "Cannot Connect", f"Host '{host.alias}' is a wildcard with no HostName — cannot connect directly.")
+            return
+
+        if self.btn_inapp.isChecked():
+            self._connect_in_app(host)
+        else:
+            self._connect_external(host)
+
+    def _connect_in_app(self, host: HostEntry) -> None:
+        # Clear previous terminal
+        if self._terminal_widget is not None:
+            self._terminal_widget.stop()
+            self.terminal_layout.removeWidget(self._terminal_widget)
+            self._terminal_widget.deleteLater()
+            self._terminal_widget = None
+
+        self.terminal_placeholder.hide()
+        widget = launch_in_app(host)
+        if widget is None:
+            self.terminal_placeholder.show()
+            QMessageBox.warning(self, "Connect Failed", "Could not start SSH session.")
+            return
+
+        self.terminal_layout.addWidget(widget, 1)  # stretch=1 so it fills available space
+        self._terminal_widget = widget
+        widget.show()
+        widget.setFocus()
+        widget.closed.connect(lambda code: self._on_terminal_closed(code, host.alias))
+        self.btn_connect.setText("Disconnect")
+        self.statusBar().showMessage(f"Connected to {host.alias}")
+
+    def _connect_external(self, host: HostEntry) -> None:
+        proc = launch_external(host)
+        if proc is None:
+            QMessageBox.warning(self, "Connect Failed", "No terminal emulator found. Install one (konsole, gnome-terminal, xterm) or use in-app terminal.")
+            return
+        self.statusBar().showMessage(f"Launched external terminal for {host.alias}")
+
+    def _on_test_connection(self) -> None:
+        row = self._selected_row()
+        if row < 0:
+            QMessageBox.information(self, "Test Connection", "Select a host first.")
+            return
+        host = self.table_model.get_host(row)
+        if host is None:
+            return
+        self.statusBar().showMessage(f"Testing {host.alias}…")
+        self._test_worker = _ConnectionTestWorker(host, self)
+        self._test_worker.finished.connect(self._on_test_finished)
+        self._test_worker.start()
+
+    def _on_test_finished(self, alias: str, result) -> None:
+        if result.success:
+            self.statusBar().showMessage(f"{alias}: reachable ({result.latency_ms} ms)", 10000)
+        else:
+            self.statusBar().showMessage(f"{alias}: {result.error}", 10000)
+            QMessageBox.warning(self, "Connection Test", f"{alias}: {result.error}")
+        self._test_worker = None
+
+    def _on_terminal_closed(self, code: int, alias: str) -> None:
+        self.statusBar().showMessage(f"Session to {alias} ended (exit {code}).")
+        if self._terminal_widget is not None:
+            self.terminal_layout.removeWidget(self._terminal_widget)
+            self._terminal_widget.deleteLater()
+            self._terminal_widget = None
+        self.terminal_placeholder.show()
+        self.btn_connect.setText("Connect")
+
+    def _on_toggle_mode(self) -> None:
+        if self.btn_inapp.isChecked():
+            self.btn_inapp.setText("In-App Terminal")
+        else:
+            self.btn_inapp.setText("External Terminal")
+
+    def _on_save(self) -> None:
+        try:
+            path = save_config(self._config, self._config_path)
+            self.statusBar().showMessage(f"Saved to {path}")
+            QMessageBox.information(self, "Saved", f"SSH config saved to {path}")
+        except Exception as e:
+            QMessageBox.critical(self, "Save Error", f"Failed to save:\n{e}")
+
+    def closeEvent(self, event) -> None:
+        if self._terminal_widget is not None:
+            self._terminal_widget.stop()
+        super().closeEvent(event)

gssh/models.py

@@ -0,0 +1,91 @@
+"""Qt table model for displaying SSH host entries."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from PyQt6.QtCore import QAbstractTableModel, QModelIndex, Qt
+from PyQt6.QtGui import QColor
+
+from .config import HostEntry
+
+
+class HostTableModel(QAbstractTableModel):
+    """Model backing the host list table view."""
+
+    COLUMNS = ["Alias", "Host", "User", "Port", "Proxy Jump"]
+    COL_KEYS = ["alias", "hostname", "user", "port", "proxy_jump"]
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._hosts: list[HostEntry] = []
+
+    @property
+    def hosts(self) -> list[HostEntry]:
+        return self._hosts
+
+    def set_hosts(self, hosts: list[HostEntry]) -> None:
+        self.beginResetModel()
+        self._hosts = hosts
+        self.endResetModel()
+
+    def add_host(self, host: HostEntry) -> None:
+        row = len(self._hosts)
+        self.beginInsertRows(QModelIndex(), row, row)
+        self._hosts.append(host)
+        self.endInsertRows()
+
+    def remove_host(self, row: int) -> None:
+        if 0 <= row < len(self._hosts):
+            self.beginRemoveRows(QModelIndex(), row, row)
+            self._hosts.pop(row)
+            self.endRemoveRows()
+
+    def update_host(self, row: int, host: HostEntry) -> None:
+        if 0 <= row < len(self._hosts):
+            self._hosts[row] = host
+            idx = self.index(row, 0)
+            self.dataChanged.emit(idx, self.index(row, len(self.COLUMNS) - 1))
+
+    def get_host(self, row: int) -> HostEntry | None:
+        if 0 <= row < len(self._hosts):
+            return self._hosts[row]
+        return None
+
+    def rowCount(self, parent: QModelIndex = QModelIndex()) -> int:
+        return len(self._hosts) if not parent.isValid() else 0
+
+    def columnCount(self, parent: QModelIndex = QModelIndex()) -> int:
+        return len(self.COLUMNS) if not parent.isValid() else 0
+
+    def headerData(self, section: int, orientation: Qt.Orientation, role: int = Qt.ItemDataRole.DisplayRole) -> Any:
+        if role == Qt.ItemDataRole.DisplayRole and orientation == Qt.Orientation.Horizontal:
+            return self.COLUMNS[section]
+        return None
+
+    def data(self, index: QModelIndex, role: int = Qt.ItemDataRole.DisplayRole) -> Any:
+        if not index.isValid() or not (0 <= index.row() < len(self._hosts)):
+            return None
+
+        host = self._hosts[index.row()]
+        col = index.column()
+
+        if role == Qt.ItemDataRole.DisplayRole:
+            key = self.COL_KEYS[col]
+            return getattr(host, key, "") or "—"
+        if role == Qt.ItemDataRole.ToolTipRole:
+            lines = [f"Alias: {host.alias}", f"Host: {host.hostname or '—'}"]
+            if host.user:
+                lines.append(f"User: {host.user}")
+            if host.port:
+                lines.append(f"Port: {host.port}")
+            if host.identity_file:
+                lines.append(f"Key: {host.identity_file}")
+            if host.proxy_jump:
+                lines.append(f"ProxyJump: {host.proxy_jump}")
+            return "\n".join(lines)
+        if role == Qt.ItemDataRole.ForegroundRole:
+            # Dim wildcard hosts slightly
+            if "*" in host.alias:
+                return QColor(Qt.GlobalColor.gray)
+        return None