ntermqt 0.1.1__py3-none-any.whl → 0.1.4__py3-none-any.whl

nterm/__main__.py

@@ -22,6 +22,7 @@ from nterm.manager import (
 )
 from nterm.terminal.widget import TerminalWidget
 from nterm.session.ssh import SSHSession
+from nterm.session.local_terminal import LocalTerminal
 from nterm.connection.profile import ConnectionProfile, AuthConfig
 from nterm.vault import CredentialManagerWidget
 from nterm.vault.resolver import CredentialResolver
@@ -225,6 +226,35 @@ class TerminalTab(QWidget):
         return True
 
 
+class LocalTerminalTab(QWidget):
+    """A terminal tab for local processes (shell, IPython, etc.)."""
+
+    def __init__(self, name: str, session: LocalTerminal, parent=None):
+        super().__init__(parent)
+        self.name = name
+        self.local_session = session
+
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(0, 0, 0, 0)
+
+        self.terminal = TerminalWidget()
+        layout.addWidget(self.terminal)
+
+        self.terminal.attach_session(self.local_session)
+
+    def connect(self):
+        """Start the local process."""
+        self.local_session.connect()
+
+    def disconnect(self):
+        """Terminate the local process."""
+        self.local_session.disconnect()
+
+    def is_connected(self) -> bool:
+        """Check if the process is still running."""
+        return self.local_session.is_connected
+
+
 class MainWindow(QMainWindow):
     """
     Main application window with session tree and tabbed terminals.
@@ -274,7 +304,7 @@ class MainWindow(QMainWindow):
         # Apply multiline threshold to all open terminals
         for i in range(self.tab_widget.count()):
             tab = self.tab_widget.widget(i)
-            if isinstance(tab, TerminalTab):
+            if isinstance(tab, (TerminalTab, LocalTerminalTab)):
                 tab.terminal.set_multiline_threshold(settings.multiline_paste_threshold)
 
 
@@ -401,6 +431,32 @@ class MainWindow(QMainWindow):
             action.triggered.connect(lambda checked, n=theme_name: self._apply_theme_by_name(n))
             theme_menu.addAction(action)
 
+        # Dev menu
+        dev_menu = menubar.addMenu("&Dev")
+
+        # IPython submenu
+        ipython_menu = dev_menu.addMenu("&IPython")
+
+        ipython_tab_action = QAction("Open in &Tab", self)
+        ipython_tab_action.setShortcut(QKeySequence("Ctrl+Shift+I"))
+        ipython_tab_action.triggered.connect(lambda: self._open_local("IPython", LocalTerminal.ipython(), "tab"))
+        ipython_menu.addAction(ipython_tab_action)
+
+        ipython_window_action = QAction("Open in &Window", self)
+        ipython_window_action.triggered.connect(lambda: self._open_local("IPython", LocalTerminal.ipython(), "window"))
+        ipython_menu.addAction(ipython_window_action)
+
+        # Shell submenu
+        shell_menu = dev_menu.addMenu("&Shell")
+
+        shell_tab_action = QAction("Open in &Tab", self)
+        shell_tab_action.triggered.connect(lambda: self._open_local("Shell", LocalTerminal(), "tab"))
+        shell_menu.addAction(shell_tab_action)
+
+        shell_window_action = QAction("Open in &Window", self)
+        shell_window_action.triggered.connect(lambda: self._open_local("Shell", LocalTerminal(), "window"))
+        shell_menu.addAction(shell_window_action)
+
     def _on_import_sessions(self):
         """Show import dialog."""
         dialog = ImportDialog(self.session_store, self)
@@ -445,7 +501,7 @@ class MainWindow(QMainWindow):
         # Update all open terminal tabs
         for i in range(self.tab_widget.count()):
             tab = self.tab_widget.widget(i)
-            if isinstance(tab, TerminalTab):
+            if isinstance(tab, (TerminalTab, LocalTerminalTab)):
                 tab.terminal.set_theme(theme)
 
     def _apply_qt_theme(self, theme: Theme):
@@ -560,6 +616,23 @@ class MainWindow(QMainWindow):
         self._child_windows.append(window)
         window.destroyed.connect(lambda: self._child_windows.remove(window))
 
+    def _open_local(self, name: str, session: LocalTerminal, mode: str):
+        """Open a local terminal session (IPython, shell, etc.)."""
+        if mode == "tab":
+            tab = LocalTerminalTab(name, session)
+            tab.terminal.set_theme(self.current_theme)
+            idx = self.tab_widget.addTab(tab, name)
+            self.tab_widget.setCurrentIndex(idx)
+            self.tab_widget.setTabToolTip(idx, f"{name} (local)")
+            tab.connect()
+        else:
+            window = LocalTerminalWindow(name, session, self.current_theme)
+            window.show()
+            if not hasattr(self, '_child_windows'):
+                self._child_windows = []
+            self._child_windows.append(window)
+            window.destroyed.connect(lambda: self._child_windows.remove(window))
+
     # -------------------------------------------------------------------------
     # Tab Management (NEW)
     # -------------------------------------------------------------------------
@@ -569,7 +642,7 @@ class MainWindow(QMainWindow):
         count = 0
         for i in range(self.tab_widget.count()):
             tab = self.tab_widget.widget(i)
-            if isinstance(tab, TerminalTab) and tab.is_connected():
+            if isinstance(tab, (TerminalTab, LocalTerminalTab)) and tab.is_connected():
                 count += 1
         return count
 
@@ -619,13 +692,29 @@ class MainWindow(QMainWindow):
 
             tab.disconnect()
 
+        elif isinstance(tab, LocalTerminalTab):
+            # Check if process is still running
+            if tab.is_connected():
+                reply = QMessageBox.question(
+                    self,
+                    "Close Tab",
+                    f"'{tab.name}' is still running.\n\n"
+                    "Terminate and close this tab?",
+                    QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
+                    QMessageBox.StandardButton.No
+                )
+                if reply != QMessageBox.StandardButton.Yes:
+                    return
+
+            tab.disconnect()
+
         self.tab_widget.removeTab(index)
 
     def _close_other_tabs(self, keep_index: int):
         """Close all tabs except the specified one."""
         active_count = self._get_active_session_count()
         tab_to_keep = self.tab_widget.widget(keep_index)
-        keep_is_active = isinstance(tab_to_keep, TerminalTab) and tab_to_keep.is_connected()
+        keep_is_active = isinstance(tab_to_keep, (TerminalTab, LocalTerminalTab)) and tab_to_keep.is_connected()
         other_active = active_count - (1 if keep_is_active else 0)
 
         if other_active > 0:
@@ -644,7 +733,7 @@ class MainWindow(QMainWindow):
         for i in range(self.tab_widget.count() - 1, -1, -1):
             if i != keep_index:
                 tab = self.tab_widget.widget(i)
-                if isinstance(tab, TerminalTab):
+                if isinstance(tab, (TerminalTab, LocalTerminalTab)):
                     tab.disconnect()
                 self.tab_widget.removeTab(i)
 
@@ -658,7 +747,7 @@ class MainWindow(QMainWindow):
         active_count = 0
         for i in range(index + 1, self.tab_widget.count()):
             tab = self.tab_widget.widget(i)
-            if isinstance(tab, TerminalTab) and tab.is_connected():
+            if isinstance(tab, (TerminalTab, LocalTerminalTab)) and tab.is_connected():
                 active_count += 1
 
         if active_count > 0:
@@ -676,7 +765,7 @@ class MainWindow(QMainWindow):
         # Close from end to avoid index shifting
         for i in range(self.tab_widget.count() - 1, index, -1):
             tab = self.tab_widget.widget(i)
-            if isinstance(tab, TerminalTab):
+            if isinstance(tab, (TerminalTab, LocalTerminalTab)):
                 tab.disconnect()
             self.tab_widget.removeTab(i)
 
@@ -702,7 +791,7 @@ class MainWindow(QMainWindow):
         # Close all tabs
         while self.tab_widget.count() > 0:
             tab = self.tab_widget.widget(0)
-            if isinstance(tab, TerminalTab):
+            if isinstance(tab, (TerminalTab, LocalTerminalTab)):
                 tab.disconnect()
             self.tab_widget.removeTab(0)
 
@@ -741,7 +830,7 @@ class MainWindow(QMainWindow):
         # Disconnect all tabs
         for i in range(self.tab_widget.count()):
             tab = self.tab_widget.widget(i)
-            if isinstance(tab, TerminalTab):
+            if isinstance(tab, (TerminalTab, LocalTerminalTab)):
                 tab.disconnect()
 
         self.session_store.close()
@@ -790,6 +879,40 @@ class TerminalWindow(QMainWindow):
         event.accept()
 
 
+class LocalTerminalWindow(QMainWindow):
+    """Standalone window for local terminal sessions."""
+
+    def __init__(self, name: str, session: LocalTerminal, theme: Theme):
+        super().__init__()
+        self.setWindowTitle(f"{name} - Local")
+        self.resize(1000, 700)
+
+        self.setStyleSheet(generate_stylesheet(theme))
+
+        self.tab = LocalTerminalTab(name, session)
+        self.tab.terminal.set_theme(theme)
+        self.setCentralWidget(self.tab)
+
+        self.tab.connect()
+
+    def closeEvent(self, event):
+        """Terminate on close with confirmation."""
+        if self.tab.is_connected():
+            reply = QMessageBox.question(
+                self,
+                "Close Window",
+                f"'{self.tab.name}' is still running.\n\nTerminate and close?",
+                QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
+                QMessageBox.StandardButton.No
+            )
+            if reply != QMessageBox.StandardButton.Yes:
+                event.ignore()
+                return
+
+        self.tab.disconnect()
+        event.accept()
+
+
 def main():
     app = QApplication(sys.argv)
 

nterm/examples/basic_terminal.py

@@ -0,0 +1,415 @@
+#!/usr/bin/env python3
+"""
+Example nterm application.
+
+Demonstrates basic usage of the terminal widget with different session types:
+- SSHSession: Paramiko-based (for password/key auth)
+- AskpassSSHSession: Native SSH with GUI prompts (recommended for YubiKey)
+- InteractiveSSHSession: Native SSH with PTY
+"""
+
+import sys
+import logging
+from PyQt6.QtWidgets import (
+    QApplication, QMainWindow, QWidget, QVBoxLayout, QHBoxLayout,
+    QComboBox, QLabel, QPushButton, QStatusBar, QLineEdit, QSpinBox,
+    QGroupBox, QFormLayout, QMessageBox, QDialog, QDialogButtonBox,
+    QInputDialog
+)
+from PyQt6.QtCore import Qt, pyqtSignal, QObject
+
+from nterm import (
+    ConnectionProfile, AuthConfig, AuthMethod, JumpHostConfig,
+    SSHSession, SessionState, TerminalWidget, Theme, ThemeEngine,
+    InteractiveSSHSession, is_pty_available
+)
+from nterm.session import AskpassSSHSession
+
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+
+class YubiKeyDialog(QDialog):
+    """Dialog shown when YubiKey touch is required."""
+    
+    def __init__(self, prompt: str, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle("YubiKey Authentication")
+        self.setModal(True)
+        self.setMinimumWidth(350)
+        
+        layout = QVBoxLayout(self)
+        
+        # Icon/visual indicator
+        icon_label = QLabel("🔑")
+        icon_label.setStyleSheet("font-size: 48px;")
+        icon_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        layout.addWidget(icon_label)
+        
+        # Prompt
+        prompt_label = QLabel(prompt)
+        prompt_label.setWordWrap(True)
+        prompt_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        prompt_label.setStyleSheet("font-size: 14px; margin: 10px;")
+        layout.addWidget(prompt_label)
+        
+        # Instructions
+        instructions = QLabel("Touch your YubiKey to authenticate...")
+        instructions.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        instructions.setStyleSheet("color: gray;")
+        layout.addWidget(instructions)
+        
+        # Cancel button
+        buttons = QDialogButtonBox(QDialogButtonBox.StandardButton.Cancel)
+        buttons.rejected.connect(self.reject)
+        layout.addWidget(buttons)
+
+
+class NTermWindow(QMainWindow):
+    """Main application window."""
+    
+    def __init__(self):
+        super().__init__()
+        self.setWindowTitle("nterm - SSH Terminal")
+        self.resize(1200, 800)
+        
+        self._session = None
+        self._theme_engine = ThemeEngine()
+        self._yubikey_dialog = None
+        
+        self._setup_ui()
+        self._apply_theme("default")
+    
+    def _setup_ui(self):
+        """Set up the user interface."""
+        central = QWidget()
+        self.setCentralWidget(central)
+        layout = QVBoxLayout(central)
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.setSpacing(0)
+        
+        # Toolbar
+        toolbar = self._create_toolbar()
+        layout.addWidget(toolbar)
+        
+        # Terminal
+        self._terminal = TerminalWidget()
+        self._terminal.session_state_changed.connect(self._on_state_changed)
+        self._terminal.interaction_required.connect(self._on_interaction)
+        layout.addWidget(self._terminal, 1)
+        
+        # Status bar
+        self._status = QStatusBar()
+        self.setStatusBar(self._status)
+        self._status.showMessage("Disconnected")
+    
+    def _create_toolbar(self) -> QWidget:
+        """Create connection toolbar."""
+        toolbar = QWidget()
+        toolbar.setFixedHeight(100)
+        layout = QHBoxLayout(toolbar)
+        layout.setContentsMargins(8, 8, 8, 8)
+        
+        # Connection group
+        conn_group = QGroupBox("Connection")
+        conn_layout = QFormLayout(conn_group)
+        conn_layout.setContentsMargins(8, 4, 8, 4)
+        
+        self._host_input = QLineEdit()
+        self._host_input.setPlaceholderText("hostname or IP")
+        self._host_input.setText("localhost")
+        conn_layout.addRow("Host:", self._host_input)
+        
+        port_layout = QHBoxLayout()
+        self._port_input = QSpinBox()
+        self._port_input.setRange(1, 65535)
+        self._port_input.setValue(22)
+        port_layout.addWidget(self._port_input)
+        
+        self._user_input = QLineEdit()
+        self._user_input.setPlaceholderText("username")
+        port_layout.addWidget(QLabel("User:"))
+        port_layout.addWidget(self._user_input)
+        conn_layout.addRow("Port:", port_layout)
+        
+        layout.addWidget(conn_group)
+        
+        # Session type group
+        session_group = QGroupBox("Session Type")
+        session_layout = QVBoxLayout(session_group)
+        session_layout.setContentsMargins(8, 4, 8, 4)
+        
+        self._session_combo = QComboBox()
+        self._session_combo.addItem("Askpass (YubiKey GUI)", "askpass")
+        self._session_combo.addItem("Interactive (PTY)", "interactive")
+        self._session_combo.addItem("Paramiko", "paramiko")
+        self._session_combo.currentIndexChanged.connect(self._on_session_type_changed)
+        session_layout.addWidget(self._session_combo)
+        
+        # Status indicator
+        self._pty_label = QLabel("✓ GUI auth prompts" if is_pty_available() else "⚠ Limited")
+        self._pty_label.setStyleSheet("color: green;" if is_pty_available() else "color: orange;")
+        session_layout.addWidget(self._pty_label)
+        
+        layout.addWidget(session_group)
+        
+        # Auth group (for Paramiko mode)
+        self._auth_group = QGroupBox("Authentication")
+        auth_layout = QFormLayout(self._auth_group)
+        auth_layout.setContentsMargins(8, 4, 8, 4)
+        
+        self._auth_combo = QComboBox()
+        self._auth_combo.addItems(["Agent", "Password", "Key File"])
+        auth_layout.addRow("Method:", self._auth_combo)
+        
+        self._password_input = QLineEdit()
+        self._password_input.setEchoMode(QLineEdit.EchoMode.Password)
+        self._password_input.setPlaceholderText("(for password auth)")
+        auth_layout.addRow("Password:", self._password_input)
+        
+        self._auth_group.setVisible(False)
+        layout.addWidget(self._auth_group)
+        
+        # Jump host group
+        jump_group = QGroupBox("Jump Host (Optional)")
+        jump_layout = QFormLayout(jump_group)
+        jump_layout.setContentsMargins(8, 4, 8, 4)
+        
+        self._jump_host_input = QLineEdit()
+        self._jump_host_input.setPlaceholderText("bastion.example.com")
+        jump_layout.addRow("Host:", self._jump_host_input)
+        
+        self._jump_user_input = QLineEdit()
+        self._jump_user_input.setPlaceholderText("(same as main if empty)")
+        jump_layout.addRow("User:", self._jump_user_input)
+        
+        layout.addWidget(jump_group)
+        
+        # Theme selector
+        theme_group = QGroupBox("Theme")
+        theme_layout = QVBoxLayout(theme_group)
+        theme_layout.setContentsMargins(8, 4, 8, 4)
+        
+        self._theme_combo = QComboBox()
+        self._theme_combo.addItems(self._theme_engine.list_themes())
+        self._theme_combo.currentTextChanged.connect(self._apply_theme)
+        theme_layout.addWidget(self._theme_combo)
+        
+        layout.addWidget(theme_group)
+        
+        # Buttons
+        btn_layout = QVBoxLayout()
+        
+        self._connect_btn = QPushButton("Connect")
+        self._connect_btn.clicked.connect(self._connect)
+        self._connect_btn.setDefault(True)
+        btn_layout.addWidget(self._connect_btn)
+        
+        self._disconnect_btn = QPushButton("Disconnect")
+        self._disconnect_btn.clicked.connect(self._disconnect)
+        self._disconnect_btn.setEnabled(False)
+        btn_layout.addWidget(self._disconnect_btn)
+        
+        layout.addLayout(btn_layout)
+        layout.addStretch()
+        
+        return toolbar
+    
+    def _on_session_type_changed(self, index: int):
+        """Handle session type change."""
+        session_type = self._session_combo.currentData()
+        self._auth_group.setVisible(session_type == "paramiko")
+        
+        # Update status label
+        if session_type == "askpass":
+            self._pty_label.setText("✓ GUI auth prompts")
+            self._pty_label.setStyleSheet("color: green;")
+        elif session_type == "interactive":
+            self._pty_label.setText("⚠ Console prompts")
+            self._pty_label.setStyleSheet("color: orange;")
+        else:
+            self._pty_label.setText("✓ Programmatic auth")
+            self._pty_label.setStyleSheet("color: green;")
+    
+    def _apply_theme(self, theme_name: str):
+        """Apply selected theme."""
+        theme = self._theme_engine.get_theme(theme_name)
+        if theme:
+            self._terminal.set_theme(theme)
+    
+    def _connect(self):
+        """Establish connection."""
+        hostname = self._host_input.text().strip()
+        port = self._port_input.value()
+        username = self._user_input.text().strip()
+        session_type = self._session_combo.currentData()
+        
+        if not hostname:
+            QMessageBox.warning(self, "Error", "Please enter a hostname")
+            return
+        
+        if not username:
+            QMessageBox.warning(self, "Error", "Please enter a username")
+            return
+        
+        # Build auth config
+        if session_type in ("askpass", "interactive"):
+            auth = AuthConfig.agent_auth(username)
+        else:
+            auth_method = self._auth_combo.currentText()
+            if auth_method == "Agent":
+                auth = AuthConfig.agent_auth(username)
+            elif auth_method == "Password":
+                password = self._password_input.text()
+                if not password:
+                    QMessageBox.warning(self, "Error", "Please enter a password")
+                    return
+                auth = AuthConfig.password_auth(username, password)
+            else:
+                auth = AuthConfig.agent_auth(username, allow_fallback=True)
+        
+        # Build jump host config if specified
+        jump_hosts = []
+        jump_host = self._jump_host_input.text().strip()
+        if jump_host:
+            jump_user = self._jump_user_input.text().strip() or username
+            jump_hosts.append(JumpHostConfig(
+                hostname=jump_host,
+                auth=AuthConfig.agent_auth(jump_user),
+            ))
+        
+        # Create profile
+        profile = ConnectionProfile(
+            name=f"{username}@{hostname}",
+            hostname=hostname,
+            port=port,
+            auth_methods=[auth],
+            jump_hosts=jump_hosts,
+            auto_reconnect=False,  # Disable for testing
+        )
+        
+        # Create appropriate session type
+        if session_type == "askpass":
+            if not is_pty_available():
+                QMessageBox.warning(self, "Error", "PTY support required")
+                return
+            self._session = AskpassSSHSession(profile)
+        elif session_type == "interactive":
+            if not is_pty_available():
+                QMessageBox.warning(self, "Error", "PTY support required")
+                return
+            self._session = InteractiveSSHSession(profile)
+        else:
+            self._session = SSHSession(profile)
+        
+        self._terminal.attach_session(self._session)
+        
+        # Connect
+        self._session.connect()
+        self._connect_btn.setEnabled(False)
+        self._disconnect_btn.setEnabled(True)
+    
+    def _disconnect(self):
+        """Disconnect session."""
+        # Close any open dialogs
+        if self._yubikey_dialog:
+            self._yubikey_dialog.close()
+            self._yubikey_dialog = None
+        
+        if self._session:
+            self._session.disconnect()
+            self._terminal.detach_session()
+            self._session = None
+        
+        self._connect_btn.setEnabled(True)
+        self._disconnect_btn.setEnabled(False)
+    
+    def _on_state_changed(self, state: SessionState, message: str):
+        """Handle session state changes."""
+        status_text = {
+            SessionState.DISCONNECTED: "Disconnected",
+            SessionState.CONNECTING: "Connecting...",
+            SessionState.AUTHENTICATING: "Authenticating...",
+            SessionState.CONNECTED: "Connected",
+            SessionState.RECONNECTING: f"Reconnecting: {message}",
+            SessionState.FAILED: f"Failed: {message}",
+        }.get(state, str(state))
+        
+        self._status.showMessage(status_text)
+        
+        # Close YubiKey dialog on connect/disconnect
+        if state in (SessionState.CONNECTED, SessionState.DISCONNECTED, SessionState.FAILED):
+            if self._yubikey_dialog:
+                self._yubikey_dialog.close()
+                self._yubikey_dialog = None
+        
+        if state == SessionState.CONNECTED:
+            self._connect_btn.setEnabled(False)
+            self._disconnect_btn.setEnabled(True)
+            self._terminal.focus()
+        elif state in (SessionState.DISCONNECTED, SessionState.FAILED):
+            self._connect_btn.setEnabled(True)
+            self._disconnect_btn.setEnabled(False)
+    
+    def _on_interaction(self, prompt: str, interaction_type: str):
+        """Handle SSH authentication prompts."""
+        logger.info(f"Interaction required: {interaction_type} - {prompt}")
+        
+        if not isinstance(self._session, AskpassSSHSession):
+            return
+        
+        if interaction_type == "yubikey_touch":
+            # Show YubiKey dialog
+            self._yubikey_dialog = YubiKeyDialog(prompt, self)
+            result = self._yubikey_dialog.exec()
+            self._yubikey_dialog = None
+            
+            if result == QDialog.DialogCode.Rejected:
+                # User cancelled
+                self._session.provide_askpass_response(False, error="Cancelled by user")
+            else:
+                # YubiKey was touched (dialog closed by external event)
+                self._session.provide_askpass_response(True, value="")
+        
+        elif interaction_type == "password":
+            # Show password dialog
+            password, ok = QInputDialog.getText(
+                self, "SSH Authentication", prompt,
+                QLineEdit.EchoMode.Password
+            )
+            
+            if ok and password:
+                self._session.provide_askpass_response(True, value=password)
+            else:
+                self._session.provide_askpass_response(False, error="Cancelled by user")
+        
+        else:
+            # Generic input
+            text, ok = QInputDialog.getText(
+                self, "SSH Authentication", prompt
+            )
+            
+            if ok:
+                self._session.provide_askpass_response(True, value=text)
+            else:
+                self._session.provide_askpass_response(False, error="Cancelled by user")
+    
+    def closeEvent(self, event):
+        """Handle window close."""
+        if self._session:
+            self._session.disconnect()
+        event.accept()
+
+
+def main():
+    app = QApplication(sys.argv)
+    app.setApplicationName("nterm")
+    
+    window = NTermWindow()
+    window.show()
+    
+    sys.exit(app.exec())
+
+
+if __name__ == "__main__":
+    main()