graphical-ssh 0.1.1__py3-none-any.whl

gssh/terminal.py

@@ -0,0 +1,490 @@
+"""In-app terminal widget using pyte + pty for a real PTY experience.
+
+Spawns an SSH process in a pseudo-terminal, feeds output through pyte
+for VT220 emulation, and renders the screen to a QWidget with scrollback
+history, colour support, and mouse-wheel scrolling.
+"""
+
+from __future__ import annotations
+
+import fcntl
+import os
+import pty
+import signal
+import struct
+import termios
+import time
+
+import pyte
+from PyQt6.QtCore import QSocketNotifier, Qt, pyqtSignal
+from PyQt6.QtGui import (
+    QColor,
+    QFont,
+    QFontMetrics,
+    QKeyEvent,
+    QPainter,
+    QPaintEvent,
+    QPen,
+)
+from PyQt6.QtWidgets import (
+    QAbstractScrollArea,
+    QWidget,
+)
+from pyte.screens import Char
+
+# pyte colour name → QColor mapping (xterm-256colour subset)
+_DEFAULT_FG = QColor(220, 220, 220)
+_DEFAULT_BG = QColor(30, 30, 30)
+
+_COLOUR_MAP: dict[str, QColor] = {
+    "black": QColor(0, 0, 0),
+    "red": QColor(205, 0, 0),
+    "green": QColor(0, 205, 0),
+    "yellow": QColor(205, 205, 0),
+    "blue": QColor(0, 0, 238),
+    "magenta": QColor(205, 0, 205),
+    "cyan": QColor(0, 205, 205),
+    "white": QColor(229, 229, 229),
+    "brightblack": QColor(127, 127, 127),
+    "brightred": QColor(255, 0, 0),
+    "brightgreen": QColor(0, 255, 0),
+    "brightyellow": QColor(255, 255, 0),
+    "brightblue": QColor(92, 92, 255),
+    "brightmagenta": QColor(255, 0, 255),
+    "brightcyan": QColor(0, 255, 255),
+    "brightwhite": QColor(255, 255, 255),
+}
+
+
+def _char_colour(name: str, default: QColor) -> QColor:
+    if name == "default":
+        return default
+    if name in _COLOUR_MAP:
+        return _COLOUR_MAP[name]
+    # pyte may pass numeric indices as strings for 256-colour mode
+    return default
+
+
+class TerminalWidget(QAbstractScrollArea):
+    """A scrollable terminal emulator widget backed by pyte with history."""
+
+    closed = pyqtSignal(int)  # exit code
+
+    SCROLLBACK = 5000  # lines of history
+
+    def __init__(self, parent: QWidget | None = None) -> None:
+        super().__init__(parent)
+        self.setFocusPolicy(Qt.FocusPolicy.StrongFocus)
+        self.setVerticalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAsNeeded)
+        self.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
+        self.setMouseTracking(True)
+
+        self._font = QFont("Monospace", 12)
+        self._font.setStyleHint(QFont.StyleHint.Monospace)
+        self._fm = QFontMetrics(self._font)
+
+        self._cols = 80
+        self._rows = 24
+        self._screen = pyte.HistoryScreen(self._cols, self._rows, self.SCROLLBACK)
+        self._stream = pyte.Stream(self._screen)
+
+        self._master_fd: int | None = None
+        self._pid: int | None = None
+        self._notifier: QSocketNotifier | None = None
+
+        self._scroll_offset = 0  # 0 = bottom (live); >0 = scrolled up N lines
+
+        # Viewport widget for painting
+        self._viewport = _TerminalViewport(self)
+        self.setViewport(self._viewport)
+
+        # Connect scrollbar
+        self.verticalScrollBar().valueChanged.connect(self._on_scroll)
+
+        cw = self._fm.horizontalAdvance("M")
+        ch = self._fm.height()
+        self.setMinimumSize(cw * 20, ch * 5)
+
+    # ── properties ──────────────────────────────────────────────
+
+    @property
+    def char_width(self) -> int:
+        return self._fm.horizontalAdvance("M")
+
+    @property
+    def char_height(self) -> int:
+        return self._fm.height()
+
+    # ── PTY lifecycle ───────────────────────────────────────────
+
+    def _set_pty_size(self) -> None:
+        if self._master_fd is None:
+            return
+        winsize = struct.pack(
+            "HHHH", self._rows, self._cols, self.char_height, self.char_width
+        )
+        try:
+            fcntl.ioctl(self._master_fd, termios.TIOCSWINSZ, winsize)
+        except OSError:
+            pass
+
+    def start(self, command: list[str]) -> None:
+        """Spawn *command* in a PTY and start reading."""
+        if self._pid is not None:
+            self.stop()
+
+        self._set_pty_size()
+
+        pid, master_fd = pty.fork()
+        if pid == 0:
+            try:
+                env = os.environ.copy()
+                env["TERM"] = "xterm-256color"
+                os.execvpe(command[0], command, env)
+            except Exception:
+                os._exit(127)
+        else:
+            self._master_fd = master_fd
+            self._pid = pid
+            self._notifier = QSocketNotifier(master_fd, QSocketNotifier.Type.Read, self)
+            self._notifier.activated.connect(self._read_pty)
+            self._notifier.setEnabled(True)
+
+    def stop(self) -> None:
+        """Kill the spawned process and stop reading."""
+        if self._notifier is not None:
+            self._notifier.setEnabled(False)
+            self._notifier.deleteLater()
+            self._notifier = None
+        if self._pid is not None:
+            try:
+                os.kill(self._pid, signal.SIGTERM)
+            except (OSError, ProcessLookupError):
+                pass
+            # Retry WNOHANG a few times to avoid leaving a zombie
+            for _ in range(10):
+                try:
+                    wpid, _ = os.waitpid(self._pid, os.WNOHANG)
+                    if wpid != 0:
+                        break
+                except (OSError, ChildProcessError):
+                    break
+                time.sleep(0.01)
+            else:
+                # Last resort: blocking wait
+                try:
+                    os.waitpid(self._pid, 0)
+                except (OSError, ChildProcessError):
+                    pass
+            self._pid = None
+        if self._master_fd is not None:
+            try:
+                os.close(self._master_fd)
+            except OSError:
+                pass
+            self._master_fd = None
+
+    # ── PTY read loop ───────────────────────────────────────────
+
+    def _read_pty(self) -> None:
+        if self._master_fd is None:
+            return
+
+        # Disable notifier while reading to prevent recursive signals
+        if self._notifier is not None:
+            self._notifier.setEnabled(False)
+
+        try:
+            try:
+                data = os.read(self._master_fd, 65536)
+            except OSError:
+                data = b""
+
+            if not data:
+                # EOF — child exited
+                self._handle_exit()
+                return
+
+            self._stream.feed(data.decode("utf-8", errors="replace"))
+
+            self._update_scrollbar()
+            self._viewport.update()
+        finally:
+            # Re-enable notifier for next read (unless fd was closed)
+            if self._notifier is not None and self._master_fd is not None:
+                self._notifier.setEnabled(True)
+
+    def _handle_exit(self) -> None:
+        """Clean up after the child process exits."""
+        if self._notifier is not None:
+            self._notifier.setEnabled(False)
+            self._notifier.deleteLater()
+            self._notifier = None
+        if self._pid is not None:
+            # Non-blocking reap first; fall back to blocking only if needed
+            try:
+                wpid, status = os.waitpid(self._pid, os.WNOHANG)
+                if wpid == 0:
+                    # Child hasn't exited yet — give it a brief grace period
+                    for _ in range(5):
+                        time.sleep(0.01)
+                        wpid, status = os.waitpid(self._pid, os.WNOHANG)
+                        if wpid != 0:
+                            break
+                    else:
+                        # Last resort: blocking wait (rare, short)
+                        _, status = os.waitpid(self._pid, 0)
+                code = os.waitstatus_to_exitcode(status)
+            except (OSError, ChildProcessError):
+                code = 0
+            self._pid = None
+        else:
+            code = 0
+        if self._master_fd is not None:
+            try:
+                os.close(self._master_fd)
+            except OSError:
+                pass
+            self._master_fd = None
+        self.closed.emit(code)
+
+    # ── scrollbar ───────────────────────────────────────────────
+
+    def _history_len(self) -> int:
+        return len(self._screen.history.top)
+
+    def _max_scroll_offset(self) -> int:
+        return self._history_len()
+
+    def _update_scrollbar(self) -> None:
+        vbar = self.verticalScrollBar()
+        hist = self._history_len()
+        total = hist + self._rows
+        vbar.blockSignals(True)
+        vbar.setRange(0, max(0, total - self._rows))
+        if self._scroll_offset == 0:
+            vbar.setValue(hist)  # bottom
+        else:
+            vbar.setValue(hist - self._scroll_offset)
+        vbar.blockSignals(False)
+
+    def _on_scroll(self, value: int) -> None:
+        hist = self._history_len()
+        self._scroll_offset = max(0, hist - value)
+        self._viewport.update()
+
+    # ── keyboard input ──────────────────────────────────────────
+
+    def keyPressEvent(self, event: QKeyEvent) -> None:
+        if self._master_fd is None:
+            return
+
+        # If scrolled up, any key sends us back to the live bottom
+        if self._scroll_offset > 0:
+            self._scroll_offset = 0
+            self._update_scrollbar()
+
+        text = event.text()
+        key = event.key()
+
+        seq = self._key_to_sequence(key, event.modifiers(), text)
+        if seq is None:
+            return
+
+        try:
+            os.write(self._master_fd, seq)
+        except OSError:
+            pass
+
+    def _key_to_sequence(self, key: int, mods: Qt.KeyboardModifier, text: str) -> bytes | None:
+        if key == Qt.Key.Key_Return or key == Qt.Key.Key_Enter:
+            return b"\r"
+        if key == Qt.Key.Key_Backspace:
+            return b"\x7f"
+        if key == Qt.Key.Key_Tab:
+            return b"\t"
+        if key == Qt.Key.Key_Escape:
+            return b"\x1b"
+        if key == Qt.Key.Key_Up:
+            return b"\x1b[A"
+        if key == Qt.Key.Key_Down:
+            return b"\x1b[B"
+        if key == Qt.Key.Key_Right:
+            return b"\x1b[C"
+        if key == Qt.Key.Key_Left:
+            return b"\x1b[D"
+        if key == Qt.Key.Key_Home:
+            return b"\x1b[H"
+        if key == Qt.Key.Key_End:
+            return b"\x1b[F"
+        if key == Qt.Key.Key_Delete:
+            return b"\x1b[3~"
+        if key == Qt.Key.Key_PageUp:
+            self._scroll_page(-1)
+            return None
+        if key == Qt.Key.Key_PageDown:
+            self._scroll_page(1)
+            return None
+
+        # Ctrl sequences
+        if mods & Qt.KeyboardModifier.ControlModifier:
+            if Qt.Key.Key_A <= key <= Qt.Key.Key_Z:
+                return bytes([key - Qt.Key.Key_A + 1])
+            if key == Qt.Key.Key_BracketLeft:
+                return b"\x1b"
+
+        # Regular text
+        if text:
+            return text.encode("utf-8")
+
+        return None
+
+    def _scroll_page(self, direction: int) -> None:
+        """Scroll one page. direction < 0 = up (into history), > 0 = down (toward live)."""
+        delta = -direction * self._rows
+        self._scroll_offset = max(
+            0, min(self._max_scroll_offset(), self._scroll_offset + delta)
+        )
+        self._update_scrollbar()
+        self._viewport.update()
+
+    # ── mouse wheel ─────────────────────────────────────────────
+
+    def wheelEvent(self, event) -> None:
+        delta = event.angleDelta().y()
+        lines = delta // 120 * 3  # 3 lines per notch; positive = scroll up into history
+        self._scroll_offset = max(
+            0, min(self._max_scroll_offset(), self._scroll_offset + lines)
+        )
+        self._update_scrollbar()
+        self._viewport.update()
+
+    # ── resize ──────────────────────────────────────────────────
+
+    def resizeEvent(self, event) -> None:
+        super().resizeEvent(event)
+        cw = self.char_width
+        ch = self.char_height
+        # Account for scrollbar width
+        vbar_w = 0
+        vbar = self.verticalScrollBar()
+        if vbar.isVisible():
+            vbar_w = vbar.width()
+        avail_w = self.width() - vbar_w
+        new_cols = max(1, avail_w // cw)
+        new_rows = max(1, self.height() // ch)
+        if new_cols != self._cols or new_rows != self._rows:
+            self._cols = new_cols
+            self._rows = new_rows
+            self._screen.resize(self._cols, self._rows)
+            self._set_pty_size()
+            self._update_scrollbar()
+
+    # ── paint ───────────────────────────────────────────────────
+
+    def _paint_terminal(self, painter: QPainter) -> None:
+        painter.setFont(self._font)
+        cw = self.char_width
+        ch = self.char_height
+
+        # Background
+        painter.fillRect(self.viewport().rect(), _DEFAULT_BG)
+
+        hist = self._history_len()
+        scroll = self._scroll_offset
+
+        # Build the list of lines to render: history (scrolled) + visible screen
+        # When scroll_offset > 0, we show history lines from the top.
+        if scroll > 0:
+            # Render history lines + current screen, shifted up by scroll
+            history_lines = list(self._screen.history.top)
+            # We want the last (hist - scroll) history lines, then all screen lines
+            start = max(0, hist - scroll)
+            visible_hist = history_lines[start:]
+            screen_lines = list(self._screen.buffer)
+
+            all_lines = visible_hist + screen_lines
+            # How many lines from the top of the viewport are "scrolled back"
+            # We render all_lines from index 0, but only the last self._rows fit
+            total = len(all_lines)
+            render_start = max(0, total - self._rows)
+        else:
+            all_lines = list(self._screen.buffer)
+            render_start = 0
+
+        # Render each line
+        for row_idx, line in enumerate(all_lines[render_start:render_start + self._rows]):
+            y = row_idx
+            py = (y + 1) * ch - self._fm.descent()
+
+            for col_idx in range(self._cols):
+                char: Char = line[col_idx] if col_idx < len(line) else Char(data=" ")
+
+                if char.data == " " and char.bg == "default" and not char.reverse:
+                    continue
+
+                # Determine colours
+                fg = _char_colour(char.fg, _DEFAULT_FG)
+                bg = _char_colour(char.bg, _DEFAULT_BG)
+
+                if char.reverse:
+                    fg, bg = bg, fg
+
+                # Fill background if non-default
+                if char.bg != "default" or char.reverse:
+                    painter.fillRect(col_idx * cw, y * ch, cw, ch, bg)
+
+                # Draw character
+                if char.data != " ":
+                    font = self._font
+                    if char.bold:
+                        font = QFont(self._font)
+                        font.setBold(True)
+                    if char.italics:
+                        font = QFont(font)
+                        font.setItalic(True)
+                    painter.setFont(font)
+                    painter.setPen(fg)
+                    painter.drawText(col_idx * cw, py, char.data)
+
+                # Underline
+                if char.underscore:
+                    pen = QPen(fg)
+                    pen.setWidth(1)
+                    painter.setPen(pen)
+                    painter.drawLine(
+                        col_idx * cw, y * ch + ch - 1,
+                        col_idx * cw + cw, y * ch + ch - 1,
+                    )
+
+        # Cursor (only when at live bottom)
+        if scroll == 0:
+            cursor = self._screen.cursor
+            if cursor.y < self._rows and cursor.x < self._cols:
+                cx = cursor.x * cw
+                cy = cursor.y * ch
+                painter.fillRect(cx, cy, cw, ch, QColor(80, 80, 80))
+                # Redraw the character under the cursor in bg colour
+                if cursor.x < len(self._screen.buffer[cursor.y]):
+                    char = self._screen.buffer[cursor.y][cursor.x]
+                    if char.data != " ":
+                        painter.setPen(_DEFAULT_BG)
+                        painter.setFont(self._font)
+                        painter.drawText(cx, (cursor.y + 1) * ch - self._fm.descent(), char.data)
+
+    def closeEvent(self, event) -> None:
+        self.stop()
+        super().closeEvent(event)
+
+
+class _TerminalViewport(QWidget):
+    """Internal viewport that delegates painting to the terminal."""
+
+    def __init__(self, terminal: TerminalWidget) -> None:
+        super().__init__(terminal)
+        self._terminal = terminal
+
+    def paintEvent(self, event: QPaintEvent) -> None:
+        painter = QPainter(self)
+        self._terminal._paint_terminal(painter)
+        painter.end()