ntermqt 0.1.9__py3-none-any.whl → 0.1.10__py3-none-any.whl

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()

nterm/manager/io.py

@@ -3,11 +3,14 @@ Session import/export functionality.
 
 Supports JSON format for portability.
 Also supports importing from TerminalTelemetry YAML format.
+Also supports simple CSV import for quick session lists.
 """
 
 from __future__ import annotations
+import csv
 import json
 import yaml
+from io import StringIO
 from pathlib import Path
 from datetime import datetime
 from typing import Optional
@@ -17,9 +20,10 @@ from PyQt6.QtWidgets import (
     QWidget, QFileDialog, QMessageBox, QDialog,
     QVBoxLayout, QHBoxLayout, QLabel, QCheckBox,
     QPushButton, QDialogButtonBox, QTreeWidget,
-    QTreeWidgetItem, QGroupBox
+    QTreeWidgetItem, QGroupBox, QComboBox, QTextEdit
 )
 from PyQt6.QtCore import Qt
+from PyQt6.QtGui import QFont
 
 from .models import SessionStore, SavedSession, SessionFolder
 
@@ -189,6 +193,133 @@ def import_sessions(
     return imported, skipped
 
 
+def import_sessions_csv(
+    store: SessionStore,
+    path: Path,
+    merge: bool = True,
+    folder_name: Optional[str] = None
+) -> tuple[int, int, int]:
+    """
+    Import sessions from CSV file.
+
+    Supports flexible column names:
+    - name/display_name/hostname → session name
+    - hostname/host/ip/address → connection hostname
+    - port → port (default 22)
+    - description/desc → description
+    - folder/folder_name/group → folder assignment
+
+    Args:
+        store: Session store instance
+        path: Input CSV file path
+        merge: If True, merge with existing. If False, skip duplicates.
+        folder_name: Override folder for all imported sessions (optional)
+
+    Returns:
+        Tuple of (folders_created, sessions_imported, sessions_skipped)
+    """
+    with open(path, newline='', encoding='utf-8-sig') as f:
+        # Sniff dialect and read
+        sample = f.read(4096)
+        f.seek(0)
+
+        try:
+            dialect = csv.Sniffer().sniff(sample)
+        except csv.Error:
+            dialect = csv.excel  # Default to standard CSV
+
+        reader = csv.DictReader(f, dialect=dialect)
+
+        # Normalize header names (lowercase, strip whitespace)
+        if reader.fieldnames:
+            reader.fieldnames = [h.lower().strip() for h in reader.fieldnames]
+
+        rows = list(reader)
+
+    if not rows:
+        return 0, 0, 0
+
+    # Column name mappings (first match wins)
+    name_cols = ['name', 'display_name', 'session_name', 'device_name', 'device']
+    host_cols = ['hostname', 'host', 'ip', 'ip_address', 'address', 'mgmt_ip']
+    port_cols = ['port', 'ssh_port']
+    desc_cols = ['description', 'desc', 'notes', 'comment']
+    folder_cols = ['folder', 'folder_name', 'group', 'site', 'location']
+
+    def find_col(row: dict, candidates: list[str]) -> Optional[str]:
+        """Find first matching column value."""
+        for col in candidates:
+            if col in row and row[col]:
+                return row[col].strip()
+        return None
+
+    # Track folders and sessions
+    folders_created = 0
+    sessions_imported = 0
+    sessions_skipped = 0
+
+    existing_sessions = {s.hostname: s for s in store.list_all_sessions()}
+    folder_cache: dict[str, int] = {}  # folder_name -> folder_id
+
+    for row in rows:
+        # Extract fields with fallbacks
+        hostname = find_col(row, host_cols)
+        if not hostname:
+            continue  # Skip rows without hostname
+
+        name = find_col(row, name_cols) or hostname
+        port_str = find_col(row, port_cols)
+        port = int(port_str) if port_str and port_str.isdigit() else 22
+        description = find_col(row, desc_cols) or ""
+
+        # Determine folder
+        row_folder = folder_name or find_col(row, folder_cols)
+        folder_id = None
+
+        if row_folder:
+            if row_folder in folder_cache:
+                folder_id = folder_cache[row_folder]
+            else:
+                # Check if folder exists
+                existing_folders = store.list_folders(None)
+                existing = next((f for f in existing_folders if f.name == row_folder), None)
+
+                if existing:
+                    folder_id = existing.id
+                else:
+                    folder_id = store.add_folder(row_folder)
+                    folders_created += 1
+
+                folder_cache[row_folder] = folder_id
+
+        # Check for duplicate
+        if hostname in existing_sessions and not merge:
+            sessions_skipped += 1
+            continue
+
+        session = SavedSession(
+            name=name,
+            description=description,
+            hostname=hostname,
+            port=port,
+            credential_name=None,
+            folder_id=folder_id,
+        )
+
+        # Update or insert
+        if hostname in existing_sessions and merge:
+            existing = existing_sessions[hostname]
+            session.id = existing.id
+            store.update_session(session)
+        else:
+            store.add_session(session)
+            existing_sessions[hostname] = session
+
+        sessions_imported += 1
+
+    return folders_created, sessions_imported, sessions_skipped
+
+
 def import_terminal_telemetry(
     store: SessionStore,
     path: Path,
@@ -359,6 +490,49 @@ class ExportDialog(QDialog):
                 )
 
 
+# =============================================================================
+# Format Help Text
+# =============================================================================
+
+CSV_HELP_TEXT = """\
+<b>CSV Format</b><br><br>
+Simple comma-separated format for quick imports from spreadsheets or other tools.<br><br>
+
+<b>Supported Columns:</b>
+<table cellspacing="4">
+<tr><td><code>name</code></td><td>Session display name (falls back to hostname)</td></tr>
+<tr><td><code>hostname</code></td><td><b>Required.</b> IP address or DNS name</td></tr>
+<tr><td><code>port</code></td><td>SSH port (default: 22)</td></tr>
+<tr><td><code>description</code></td><td>Optional notes</td></tr>
+<tr><td><code>folder</code></td><td>Folder name (created if missing)</td></tr>
+</table>
+<br>
+<b>Example:</b><br>
+<code>name,hostname,port,folder<br>
+core-rtr-01,10.0.0.1,22,Core<br>
+core-rtr-02,10.0.0.2,22,Core<br>
+edge-sw-01,10.1.0.1,22,Edge</code><br><br>
+
+<i>Column names are flexible: "host", "ip", "address" also work for hostname.</i>
+"""
+
+JSON_HELP_TEXT = """\
+<b>JSON Format</b><br><br>
+Native nterm export format. Preserves folders, hierarchy, and all session metadata.<br><br>
+
+<b>Structure:</b><br>
+<code>{<br>
+&nbsp;&nbsp;"version": 1,<br>
+&nbsp;&nbsp;"folders": [{"id": 1, "name": "Site A", ...}],<br>
+&nbsp;&nbsp;"sessions": [<br>
+&nbsp;&nbsp;&nbsp;&nbsp;{"name": "router-01", "hostname": "10.0.0.1", "port": 22, "folder_id": 1}<br>
+&nbsp;&nbsp;]<br>
+}</code><br><br>
+
+<b>Tip:</b> Use <i>Export Sessions</i> to create a template, then edit and re-import.
+"""
+
+
 class ImportDialog(QDialog):
     """Dialog for import options and preview."""
 
@@ -366,14 +540,45 @@ class ImportDialog(QDialog):
         super().__init__(parent)
         self.store = store
         self._import_path: Optional[Path] = None
-        self._import_data: Optional[dict] = None
+        self._import_data = None  # Can be dict (JSON) or list of rows (CSV)
+        self._import_format: str = "json"
 
         self.setWindowTitle("Import Sessions")
-        self.setMinimumWidth(500)
-        self.setMinimumHeight(400)
+        self.setMinimumWidth(600)
+        self.setMinimumHeight(500)
 
         layout = QVBoxLayout(self)
 
+        # Format selection row
+        format_row = QHBoxLayout()
+        format_row.addWidget(QLabel("Format:"))
+
+        self._format_combo = QComboBox()
+        self._format_combo.addItem("JSON (nterm native)", "json")
+        self._format_combo.addItem("CSV (spreadsheet)", "csv")
+        self._format_combo.currentIndexChanged.connect(self._on_format_changed)
+        self._format_combo.setMinimumWidth(180)
+        format_row.addWidget(self._format_combo)
+
+        format_row.addStretch()
+
+        # Help toggle
+        self._help_btn = QPushButton("? Help")
+        self._help_btn.setCheckable(True)
+        self._help_btn.setMaximumWidth(80)
+        self._help_btn.toggled.connect(self._toggle_help)
+        format_row.addWidget(self._help_btn)
+
+        layout.addLayout(format_row)
+
+        # Help panel (hidden by default)
+        self._help_panel = QTextEdit()
+        self._help_panel.setReadOnly(True)
+        self._help_panel.setMaximumHeight(180)
+        self._help_panel.setHtml(JSON_HELP_TEXT)
+        self._help_panel.hide()
+        layout.addWidget(self._help_panel)
+
         # File selection
         file_row = QHBoxLayout()
         self._file_label = QLabel("No file selected")
@@ -392,6 +597,7 @@ class ImportDialog(QDialog):
         self._preview_tree = QTreeWidget()
         self._preview_tree.setHeaderLabels(["Name", "Host", "Port"])
         self._preview_tree.setRootIsDecorated(True)
+        self._preview_tree.setAlternatingRowColors(True)
         preview_layout.addWidget(self._preview_tree)
 
         layout.addWidget(preview_group)
@@ -421,13 +627,41 @@ class ImportDialog(QDialog):
         self._button_box.button(QDialogButtonBox.StandardButton.Ok).setText("Import")
         layout.addWidget(self._button_box)
 
+    def _on_format_changed(self, index: int) -> None:
+        """Handle format selection change."""
+        self._import_format = self._format_combo.currentData()
+
+        # Update help text
+        if self._import_format == "csv":
+            self._help_panel.setHtml(CSV_HELP_TEXT)
+        else:
+            self._help_panel.setHtml(JSON_HELP_TEXT)
+
+        # Clear preview if format changed after file loaded
+        if self._import_path:
+            self._preview_tree.clear()
+            self._import_path = None
+            self._import_data = None
+            self._file_label.setText("No file selected")
+            self._button_box.button(QDialogButtonBox.StandardButton.Ok).setEnabled(False)
+
+    def _toggle_help(self, show: bool) -> None:
+        """Show/hide help panel."""
+        self._help_panel.setVisible(show)
+        self._help_btn.setText("▼ Help" if show else "? Help")
+
     def _browse_file(self) -> None:
         """Browse for import file."""
+        if self._import_format == "csv":
+            filter_str = "CSV Files (*.csv);;All Files (*)"
+        else:
+            filter_str = "JSON Files (*.json);;All Files (*)"
+
         path, _ = QFileDialog.getOpenFileName(
             self,
             "Import Sessions",
             "",
-            "JSON Files (*.json);;All Files (*)"
+            filter_str
         )
 
         if path:
@@ -436,47 +670,19 @@ class ImportDialog(QDialog):
     def _load_preview(self, path: Path) -> None:
         """Load and preview import file."""
         try:
-            with open(path) as f:
-                data = json.load(f)
+            self._preview_tree.clear()
+
+            if self._import_format == "csv":
+                self._load_csv_preview(path)
+            else:
+                self._load_json_preview(path)
 
             self._import_path = path
-            self._import_data = data
             self._file_label.setText(path.name)
 
-            # Build preview tree
-            self._preview_tree.clear()
-
-            # Create folder items
-            folder_items: dict[int, QTreeWidgetItem] = {}
-            for folder_data in data.get("folders", []):
-                item = QTreeWidgetItem()
-                item.setText(0, f"📁 {folder_data['name']}")
-                folder_items[folder_data["id"]] = item
-
-            # Parent folders
-            for folder_data in data.get("folders", []):
-                item = folder_items[folder_data["id"]]
-                parent_id = folder_data.get("parent_id")
-                if parent_id and parent_id in folder_items:
-                    folder_items[parent_id].addChild(item)
-                else:
-                    self._preview_tree.addTopLevelItem(item)
-
-            # Add sessions
-            for session_data in data.get("sessions", []):
-                item = QTreeWidgetItem()
-                item.setText(0, session_data.get("name", ""))
-                item.setText(1, session_data.get("hostname", ""))
-                item.setText(2, str(session_data.get("port", 22)))
-
-                folder_id = session_data.get("folder_id")
-                if folder_id and folder_id in folder_items:
-                    folder_items[folder_id].addChild(item)
-                else:
-                    self._preview_tree.addTopLevelItem(item)
-
             self._preview_tree.expandAll()
-            self._preview_tree.resizeColumnToContents(0)
+            for i in range(3):
+                self._preview_tree.resizeColumnToContents(i)
 
             # Enable import button
             self._button_box.button(QDialogButtonBox.StandardButton.Ok).setEnabled(True)
@@ -488,19 +694,126 @@ class ImportDialog(QDialog):
                 f"Failed to load file:\n{e}"
             )
 
+    def _load_csv_preview(self, path: Path) -> None:
+        """Load CSV file and populate preview."""
+        with open(path, newline='', encoding='utf-8-sig') as f:
+            sample = f.read(4096)
+            f.seek(0)
+
+            try:
+                dialect = csv.Sniffer().sniff(sample)
+            except csv.Error:
+                dialect = csv.excel
+
+            reader = csv.DictReader(f, dialect=dialect)
+            if reader.fieldnames:
+                reader.fieldnames = [h.lower().strip() for h in reader.fieldnames]
+
+            rows = list(reader)
+
+        self._import_data = rows
+
+        # Column mappings
+        name_cols = ['name', 'display_name', 'session_name', 'device_name', 'device']
+        host_cols = ['hostname', 'host', 'ip', 'ip_address', 'address', 'mgmt_ip']
+        port_cols = ['port', 'ssh_port']
+        folder_cols = ['folder', 'folder_name', 'group', 'site', 'location']
+
+        def find_col(row: dict, candidates: list[str]) -> Optional[str]:
+            for col in candidates:
+                if col in row and row[col]:
+                    return row[col].strip()
+            return None
+
+        # Group by folder for preview
+        folder_items: dict[str, QTreeWidgetItem] = {}
+        root_sessions: list[QTreeWidgetItem] = []
+
+        for row in rows:
+            hostname = find_col(row, host_cols)
+            if not hostname:
+                continue
+
+            name = find_col(row, name_cols) or hostname
+            port = find_col(row, port_cols) or "22"
+            folder = find_col(row, folder_cols)
+
+            item = QTreeWidgetItem()
+            item.setText(0, name)
+            item.setText(1, hostname)
+            item.setText(2, port)
+
+            if folder:
+                if folder not in folder_items:
+                    folder_item = QTreeWidgetItem()
+                    folder_item.setText(0, f"📁 {folder}")
+                    self._preview_tree.addTopLevelItem(folder_item)
+                    folder_items[folder] = folder_item
+                folder_items[folder].addChild(item)
+            else:
+                root_sessions.append(item)
+
+        # Add ungrouped sessions at root
+        for item in root_sessions:
+            self._preview_tree.addTopLevelItem(item)
+
+    def _load_json_preview(self, path: Path) -> None:
+        """Load JSON file and populate preview."""
+        with open(path) as f:
+            data = json.load(f)
+
+        self._import_data = data
+
+        # Create folder items
+        folder_items: dict[int, QTreeWidgetItem] = {}
+        for folder_data in data.get("folders", []):
+            item = QTreeWidgetItem()
+            item.setText(0, f"📁 {folder_data['name']}")
+            folder_items[folder_data["id"]] = item
+
+        # Parent folders
+        for folder_data in data.get("folders", []):
+            item = folder_items[folder_data["id"]]
+            parent_id = folder_data.get("parent_id")
+            if parent_id and parent_id in folder_items:
+                folder_items[parent_id].addChild(item)
+            else:
+                self._preview_tree.addTopLevelItem(item)
+
+        # Add sessions
+        for session_data in data.get("sessions", []):
+            item = QTreeWidgetItem()
+            item.setText(0, session_data.get("name", ""))
+            item.setText(1, session_data.get("hostname", ""))
+            item.setText(2, str(session_data.get("port", 22)))
+
+            folder_id = session_data.get("folder_id")
+            if folder_id and folder_id in folder_items:
+                folder_items[folder_id].addChild(item)
+            else:
+                self._preview_tree.addTopLevelItem(item)
+
     def _on_import(self) -> None:
         """Perform import."""
         if not self._import_path:
             return
 
         try:
-            imported, skipped = import_sessions(
-                self.store,
-                self._import_path,
-                merge=self._merge_check.isChecked()
-            )
+            if self._import_format == "csv":
+                folders, imported, skipped = import_sessions_csv(
+                    self.store,
+                    self._import_path,
+                    merge=self._merge_check.isChecked()
+                )
+                msg = f"Created {folders} folders.\nImported {imported} sessions."
+            else:
+                imported, skipped = import_sessions(
+                    self.store,
+                    self._import_path,
+                    merge=self._merge_check.isChecked()
+                )
+                msg = f"Imported {imported} sessions."
 
-            msg = f"Imported {imported} sessions."
             if skipped:
                 msg += f"\nSkipped {skipped} duplicates."
 

{ntermqt-0.1.9.dist-info → ntermqt-0.1.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ntermqt
-Version: 0.1.9
+Version: 0.1.10
 Summary: Modern SSH terminal widget for PyQt6 with credential vault and jump host support
 Author: Scott Peterman
 License: GPL-3.0

{ntermqt-0.1.9.dist-info → ntermqt-0.1.10.dist-info}/RECORD

@@ -6,10 +6,11 @@ nterm/askpass/__init__.py,sha256=UpJBk0EOm0nkRwMVv7YdIB4v75ZJpSYmNsU_GlgzbUg,495
 nterm/askpass/server.py,sha256=5tvjYryyfu-n8Cw2KbucwaZfWiqYnFk-iBAVBI8FMfw,12873
 nterm/connection/__init__.py,sha256=2qQ9LGxUxmwem8deOD2WZVkeD6rIVlTlx5Zh2cUEmxY,261
 nterm/connection/profile.py,sha256=4RMgnRNKCc-dFGEIpmQc_bob5MtzxO04_PljP-qUGLs,9450
+nterm/examples/basic_terminal.py,sha256=vbDI1xl-Radv6GYZ0yC6QUafQp_tSX2pWIf7tk58W8E,15256
 nterm/manager/__init__.py,sha256=_QIeTap5CTL3jdTS1Q16fAt-PrqcNPUVr9gtJ22f0ng,774
 nterm/manager/connect_dialog.py,sha256=yd8g_gYttT_UdflRxSfyss8OQTfrvKLUOMg4Kj8FPNo,11711
 nterm/manager/editor.py,sha256=Fn2YWHJ1EwPYrhKhsi4GTBYwRfCYsHsqgKkLY-LQ8JI,8469
-nterm/manager/io.py,sha256=R5ksWgpEz0VdVCokcgTN5G3PFgp5QYhjjt40OypSWkY,21687
+nterm/manager/io.py,sha256=59ehTfnS1sAKEEEwMxujHuccV7rYSoRx4vfS1ExDqW4,32572
 nterm/manager/models.py,sha256=cvC2HzCRadNG1EYsnZN4C9YS6uolHGcUGGZtt-wzGF4,12237
 nterm/manager/settings.py,sha256=r6MTw_9r1Wl2UX_ALpXIuPbDvJ0D91Y8wRKq6Bfr_3g,9210
 nterm/manager/tree.py,sha256=I78wSjkSuyM6903II-XNyPug9saMSODUNBCHCDrq4ls,22397
@@ -66,8 +67,8 @@ nterm/vault/manager_ui.py,sha256=qle-W40j6L_pOR0AaOCeyU8myizFTRkISNrloCn0H_Y,345
 nterm/vault/profile.py,sha256=qM9TJf68RKdjtxo-sJehO7wS4iTi2G26BKbmlmHLA5M,6246
 nterm/vault/resolver.py,sha256=GWB2YR9H1MH98RGQBKvitIsjWT_-wSMLuddZNz4wbns,7800
 nterm/vault/store.py,sha256=_0Lfe0WKjm3uSAtxgn9qAPlpBOLCuq9SVgzqsE_qaGQ,21199
-ntermqt-0.1.9.dist-info/METADATA,sha256=ICYH7EjefVJLe_Hp-prpK8GPQE2TTqEaoX7-x2M0cOo,16040
-ntermqt-0.1.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ntermqt-0.1.9.dist-info/entry_points.txt,sha256=Gunr-_3w-aSpfqoMuGKM2PJSCRo9hZ7K1BksUtp1yd8,130
-ntermqt-0.1.9.dist-info/top_level.txt,sha256=bZdnNLTHNRNqo9jsOQGUWF7h5st0xW_thH0n2QOxWUo,6
-ntermqt-0.1.9.dist-info/RECORD,,
+ntermqt-0.1.10.dist-info/METADATA,sha256=Pa4Oytg8jq0W5pU0bmmJR9nryjKRwewy54qejJValjM,16041
+ntermqt-0.1.10.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+ntermqt-0.1.10.dist-info/entry_points.txt,sha256=Gunr-_3w-aSpfqoMuGKM2PJSCRo9hZ7K1BksUtp1yd8,130
+ntermqt-0.1.10.dist-info/top_level.txt,sha256=bZdnNLTHNRNqo9jsOQGUWF7h5st0xW_thH0n2QOxWUo,6
+ntermqt-0.1.10.dist-info/RECORD,,

{ntermqt-0.1.9.dist-info → ntermqt-0.1.10.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any