ntermqt 0.1.0__py3-none-any.whl

nterm/manager/models.py

@@ -0,0 +1,346 @@
+"""
+Session manager data models and storage.
+"""
+
+from __future__ import annotations
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+from datetime import datetime
+import sqlite3
+import logging
+import json
+
+logger = logging.getLogger(__name__)
+
+# Default database location (alongside vault.db)
+DEFAULT_DB_PATH = Path.home() / ".nterm" / "sessions.db"
+
+
+@dataclass
+class SavedSession:
+    """A saved session bookmark."""
+    id: Optional[int] = None
+    name: str = ""
+    description: str = ""
+    hostname: str = ""
+    port: int = 22
+
+    # Reference to credential in vault (by name), or None for agent auth
+    credential_name: Optional[str] = None
+
+    # Organization
+    folder_id: Optional[int] = None
+    position: int = 0
+
+    # Metadata
+    created_at: Optional[datetime] = None
+    last_connected: Optional[datetime] = None
+    connect_count: int = 0
+
+    # Optional overrides (JSON-serialized extras)
+    extras: dict = field(default_factory=dict)
+
+    def __post_init__(self):
+        if isinstance(self.extras, str):
+            self.extras = json.loads(self.extras) if self.extras else {}
+
+
+@dataclass
+class SessionFolder:
+    """A folder for organizing sessions."""
+    id: Optional[int] = None
+    name: str = ""
+    parent_id: Optional[int] = None  # None = root level
+    position: int = 0
+    expanded: bool = True
+
+
+class SessionStore:
+    """
+    SQLite-backed storage for saved sessions.
+    """
+
+    def __init__(self, db_path: Path = None):
+        self.db_path = db_path or DEFAULT_DB_PATH
+        self._conn: Optional[sqlite3.Connection] = None
+        self._ensure_db()
+
+    def _ensure_db(self) -> None:
+        """Create database and tables if needed."""
+        self.db_path.parent.mkdir(parents=True, exist_ok=True)
+
+        conn = sqlite3.connect(self.db_path)
+        conn.row_factory = sqlite3.Row
+
+        conn.executescript("""
+            CREATE TABLE IF NOT EXISTS folders (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                name TEXT NOT NULL,
+                parent_id INTEGER REFERENCES folders(id) ON DELETE CASCADE,
+                position INTEGER DEFAULT 0,
+                expanded INTEGER DEFAULT 1
+            );
+            
+            CREATE TABLE IF NOT EXISTS sessions (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                name TEXT NOT NULL,
+                description TEXT DEFAULT '',
+                hostname TEXT NOT NULL,
+                port INTEGER DEFAULT 22,
+                credential_name TEXT,
+                folder_id INTEGER REFERENCES folders(id) ON DELETE SET NULL,
+                position INTEGER DEFAULT 0,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                last_connected TIMESTAMP,
+                connect_count INTEGER DEFAULT 0,
+                extras TEXT DEFAULT '{}'
+            );
+            
+            CREATE INDEX IF NOT EXISTS idx_sessions_folder ON sessions(folder_id);
+            CREATE INDEX IF NOT EXISTS idx_folders_parent ON folders(parent_id);
+        """)
+
+        conn.commit()
+        self._conn = conn
+
+    def close(self) -> None:
+        """Close database connection."""
+        if self._conn:
+            self._conn.close()
+            self._conn = None
+
+    # -------------------------------------------------------------------------
+    # Folder operations
+    # -------------------------------------------------------------------------
+
+    def add_folder(self, name: str, parent_id: int = None) -> int:
+        """Create a new folder. Returns folder ID."""
+        cursor = self._conn.execute(
+            "SELECT COALESCE(MAX(position), -1) + 1 FROM folders WHERE parent_id IS ?",
+            (parent_id,)
+        )
+        position = cursor.fetchone()[0]
+
+        cursor = self._conn.execute(
+            "INSERT INTO folders (name, parent_id, position) VALUES (?, ?, ?)",
+            (name, parent_id, position)
+        )
+        self._conn.commit()
+        return cursor.lastrowid
+
+    def get_folder(self, folder_id: int) -> Optional[SessionFolder]:
+        """Get folder by ID."""
+        cursor = self._conn.execute(
+            "SELECT * FROM folders WHERE id = ?", (folder_id,)
+        )
+        row = cursor.fetchone()
+        return self._row_to_folder(row) if row else None
+
+    def list_folders(self, parent_id: int = None) -> list[SessionFolder]:
+        """List folders under a parent (None = root level)."""
+        cursor = self._conn.execute(
+            "SELECT * FROM folders WHERE parent_id IS ? ORDER BY position, name",
+            (parent_id,)
+        )
+        return [self._row_to_folder(row) for row in cursor]
+
+    def update_folder(self, folder: SessionFolder) -> bool:
+        """Update folder properties."""
+        self._conn.execute(
+            """UPDATE folders 
+               SET name = ?, parent_id = ?, position = ?, expanded = ?
+               WHERE id = ?""",
+            (folder.name, folder.parent_id, folder.position,
+             1 if folder.expanded else 0, folder.id)
+        )
+        self._conn.commit()
+        return True
+
+    def delete_folder(self, folder_id: int) -> bool:
+        """Delete folder (sessions inside move to root)."""
+        # Move sessions to root first
+        self._conn.execute(
+            "UPDATE sessions SET folder_id = NULL WHERE folder_id = ?",
+            (folder_id,)
+        )
+        # Move subfolders to root
+        self._conn.execute(
+            "UPDATE folders SET parent_id = NULL WHERE parent_id = ?",
+            (folder_id,)
+        )
+        # Delete folder
+        self._conn.execute("DELETE FROM folders WHERE id = ?", (folder_id,))
+        self._conn.commit()
+        return True
+
+    def _row_to_folder(self, row: sqlite3.Row) -> SessionFolder:
+        return SessionFolder(
+            id=row["id"],
+            name=row["name"],
+            parent_id=row["parent_id"],
+            position=row["position"],
+            expanded=bool(row["expanded"]),
+        )
+
+    # -------------------------------------------------------------------------
+    # Session operations
+    # -------------------------------------------------------------------------
+
+    def add_session(self, session: SavedSession) -> int:
+        """Add a new session. Returns session ID."""
+        cursor = self._conn.execute(
+            "SELECT COALESCE(MAX(position), -1) + 1 FROM sessions WHERE folder_id IS ?",
+            (session.folder_id,)
+        )
+        position = cursor.fetchone()[0]
+
+        cursor = self._conn.execute(
+            """INSERT INTO sessions 
+               (name, description, hostname, port, credential_name, folder_id, position, extras)
+               VALUES (?, ?, ?, ?, ?, ?, ?, ?)""",
+            (session.name, session.description, session.hostname, session.port,
+             session.credential_name, session.folder_id, position,
+             json.dumps(session.extras))
+        )
+        self._conn.commit()
+        return cursor.lastrowid
+
+    def get_session(self, session_id: int) -> Optional[SavedSession]:
+        """Get session by ID."""
+        cursor = self._conn.execute(
+            "SELECT * FROM sessions WHERE id = ?", (session_id,)
+        )
+        row = cursor.fetchone()
+        return self._row_to_session(row) if row else None
+
+    def list_sessions(self, folder_id: int = None) -> list[SavedSession]:
+        """List sessions in a folder (None = root level)."""
+        cursor = self._conn.execute(
+            "SELECT * FROM sessions WHERE folder_id IS ? ORDER BY position, name",
+            (folder_id,)
+        )
+        return [self._row_to_session(row) for row in cursor]
+
+    def list_all_sessions(self) -> list[SavedSession]:
+        """List all sessions regardless of folder."""
+        cursor = self._conn.execute(
+            "SELECT * FROM sessions ORDER BY name"
+        )
+        return [self._row_to_session(row) for row in cursor]
+
+    def update_session(self, session: SavedSession) -> bool:
+        """Update session properties."""
+        self._conn.execute(
+            """UPDATE sessions 
+               SET name = ?, description = ?, hostname = ?, port = ?,
+                   credential_name = ?, folder_id = ?, position = ?, extras = ?
+               WHERE id = ?""",
+            (session.name, session.description, session.hostname, session.port,
+             session.credential_name, session.folder_id, session.position,
+             json.dumps(session.extras), session.id)
+        )
+        self._conn.commit()
+        return True
+
+    def delete_session(self, session_id: int) -> bool:
+        """Delete a session."""
+        self._conn.execute("DELETE FROM sessions WHERE id = ?", (session_id,))
+        self._conn.commit()
+        return True
+
+    def record_connect(self, session_id: int) -> None:
+        """Record that a session was connected to."""
+        self._conn.execute(
+            """UPDATE sessions 
+               SET last_connected = CURRENT_TIMESTAMP, connect_count = connect_count + 1
+               WHERE id = ?""",
+            (session_id,)
+        )
+        self._conn.commit()
+
+    def search_sessions(self, query: str) -> list[SavedSession]:
+        """Search sessions by name, description, or hostname."""
+        pattern = f"%{query}%"
+        cursor = self._conn.execute(
+            """SELECT * FROM sessions 
+               WHERE name LIKE ? OR description LIKE ? OR hostname LIKE ?
+               ORDER BY name""",
+            (pattern, pattern, pattern)
+        )
+        return [self._row_to_session(row) for row in cursor]
+
+    def _row_to_session(self, row: sqlite3.Row) -> SavedSession:
+        return SavedSession(
+            id=row["id"],
+            name=row["name"],
+            description=row["description"],
+            hostname=row["hostname"],
+            port=row["port"],
+            credential_name=row["credential_name"],
+            folder_id=row["folder_id"],
+            position=row["position"],
+            created_at=row["created_at"],
+            last_connected=row["last_connected"],
+            connect_count=row["connect_count"],
+            extras=row["extras"],
+        )
+
+    # -------------------------------------------------------------------------
+    # Bulk / tree operations
+    # -------------------------------------------------------------------------
+
+    def get_tree(self) -> dict:
+        """
+        Get full tree structure for UI.
+
+        Returns dict with:
+            - folders: list of SessionFolder (all)
+            - sessions: list of SavedSession (all)
+        """
+        folders = []
+        cursor = self._conn.execute("SELECT * FROM folders ORDER BY position, name")
+        for row in cursor:
+            folders.append(self._row_to_folder(row))
+
+        sessions = self.list_all_sessions()
+
+        return {"folders": folders, "sessions": sessions}
+
+    def move_session(self, session_id: int, folder_id: int = None) -> None:
+        """Move session to a different folder."""
+        # Get new position at end of target folder
+        cursor = self._conn.execute(
+            "SELECT COALESCE(MAX(position), -1) + 1 FROM sessions WHERE folder_id IS ?",
+            (folder_id,)
+        )
+        position = cursor.fetchone()[0]
+
+        self._conn.execute(
+            "UPDATE sessions SET folder_id = ?, position = ? WHERE id = ?",
+            (folder_id, position, session_id)
+        )
+        self._conn.commit()
+
+    def move_folder(self, folder_id: int, parent_id: int = None) -> None:
+        """Move folder to a different parent."""
+        # Prevent circular reference
+        if parent_id:
+            current = parent_id
+            while current:
+                if current == folder_id:
+                    raise ValueError("Cannot move folder into itself")
+                folder = self.get_folder(current)
+                current = folder.parent_id if folder else None
+
+        cursor = self._conn.execute(
+            "SELECT COALESCE(MAX(position), -1) + 1 FROM folders WHERE parent_id IS ?",
+            (parent_id,)
+        )
+        position = cursor.fetchone()[0]
+
+        self._conn.execute(
+            "UPDATE folders SET parent_id = ?, position = ? WHERE id = ?",
+            (parent_id, position, folder_id)
+        )
+        self._conn.commit()

nterm/manager/settings.py

@@ -0,0 +1,264 @@
+"""
+Settings dialog with theme selection and persistence.
+"""
+
+from __future__ import annotations
+from typing import Optional
+
+from PyQt6.QtWidgets import (
+    QDialog, QVBoxLayout, QHBoxLayout, QFormLayout,
+    QComboBox, QSpinBox, QPushButton,
+    QDialogButtonBox, QGroupBox, QLabel, QWidget,
+    QFrame, QCheckBox
+)
+from PyQt6.QtCore import pyqtSignal
+from PyQt6.QtGui import QFont
+
+from nterm.theme.engine import ThemeEngine, Theme
+from nterm.config import get_settings, save_settings, AppSettings
+
+
+class ThemePreview(QFrame):
+    """Small preview of theme colors."""
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setFixedHeight(60)
+        self.setFrameStyle(QFrame.Shape.Box | QFrame.Shadow.Sunken)
+        self._theme: Optional[Theme] = None
+        self._update_style()
+
+    def set_theme(self, theme: Theme) -> None:
+        """Update preview with theme colors."""
+        self._theme = theme
+        self._update_style()
+
+    def _update_style(self) -> None:
+        if not self._theme:
+            return
+
+        colors = self._theme.terminal_colors
+        bg = colors.get("background", "#1e1e2e")
+        fg = colors.get("foreground", "#cdd6f4")
+
+        # Build color swatches
+        swatch_colors = [
+            colors.get("red", "#f38ba8"),
+            colors.get("green", "#a6e3a1"),
+            colors.get("yellow", "#f9e2af"),
+            colors.get("blue", "#89b4fa"),
+            colors.get("magenta", "#f5c2e7"),
+            colors.get("cyan", "#94e2d5"),
+        ]
+
+        self.setStyleSheet(f"""
+            ThemePreview {{
+                background-color: {bg};
+                border: 1px solid {self._theme.border_color};
+                border-radius: 4px;
+            }}
+        """)
+
+        # Clear existing widgets
+        if self.layout():
+            while self.layout().count():
+                child = self.layout().takeAt(0)
+                if child.widget():
+                    child.widget().deleteLater()
+        else:
+            layout = QHBoxLayout(self)
+            layout.setContentsMargins(8, 8, 8, 8)
+            layout.setSpacing(4)
+
+        # Add sample text
+        sample = QLabel("user@host:~$")
+        sample.setStyleSheet(f"color: {fg}; background: transparent;")
+        sample.setFont(QFont(self._theme.font_family.split(",")[0].strip(), 11))
+        self.layout().addWidget(sample)
+
+        self.layout().addStretch()
+
+        # Add color swatches
+        for color in swatch_colors:
+            swatch = QFrame()
+            swatch.setFixedSize(16, 16)
+            swatch.setStyleSheet(f"""
+                background-color: {color};
+                border-radius: 2px;
+            """)
+            self.layout().addWidget(swatch)
+
+
+class SettingsDialog(QDialog):
+    """
+    Application settings dialog with persistence.
+
+    Signals:
+        theme_changed(theme): Emitted when theme selection changes
+        settings_changed(settings): Emitted when any settings change
+    """
+
+    theme_changed = pyqtSignal(object)  # Theme
+    settings_changed = pyqtSignal(object)  # AppSettings
+
+    def __init__(
+            self,
+            theme_engine: ThemeEngine,
+            current_theme: Theme = None,
+            parent: QWidget = None
+    ):
+        super().__init__(parent)
+        self.theme_engine = theme_engine
+        self._settings = get_settings()
+        self._current_theme = current_theme or theme_engine.current
+        self._original_theme = self._current_theme
+        self._original_settings = AppSettings.from_dict(self._settings.to_dict())
+
+        self._setup_ui()
+        self._load_settings()
+
+    def _setup_ui(self) -> None:
+        """Build the dialog UI."""
+        self.setWindowTitle("Settings")
+        self.setMinimumWidth(450)
+
+        layout = QVBoxLayout(self)
+
+        # Theme group
+        theme_group = QGroupBox("Appearance")
+        theme_layout = QVBoxLayout(theme_group)
+
+        # Theme selector
+        selector_row = QHBoxLayout()
+        selector_row.addWidget(QLabel("Theme:"))
+
+        self._theme_combo = QComboBox()
+        for name in self.theme_engine.list_themes():
+            self._theme_combo.addItem(name.replace("_", " ").title(), name)
+        self._theme_combo.currentIndexChanged.connect(self._on_theme_changed)
+        selector_row.addWidget(self._theme_combo, 1)
+
+        theme_layout.addLayout(selector_row)
+
+        # Theme preview
+        self._preview = ThemePreview()
+        theme_layout.addWidget(self._preview)
+
+        layout.addWidget(theme_group)
+
+        # Font group
+        font_group = QGroupBox("Terminal Font")
+        font_layout = QFormLayout(font_group)
+
+        self._font_size_spin = QSpinBox()
+        self._font_size_spin.setRange(8, 32)
+        self._font_size_spin.setValue(14)
+        self._font_size_spin.setSuffix(" pt")
+        font_layout.addRow("Size:", self._font_size_spin)
+
+        layout.addWidget(font_group)
+
+        # Terminal behavior group
+        behavior_group = QGroupBox("Terminal Behavior")
+        behavior_layout = QFormLayout(behavior_group)
+
+        self._multiline_spin = QSpinBox()
+        self._multiline_spin.setRange(0, 100)
+        self._multiline_spin.setValue(self._settings.multiline_paste_threshold)
+        self._multiline_spin.setSpecialValueText("Disabled")
+        self._multiline_spin.setToolTip("Warn before pasting text with more than this many lines (0 to disable)")
+        behavior_layout.addRow("Multiline paste warning:", self._multiline_spin)
+
+        self._scrollback_spin = QSpinBox()
+        self._scrollback_spin.setRange(1000, 100000)
+        self._scrollback_spin.setSingleStep(1000)
+        self._scrollback_spin.setValue(self._settings.scrollback_lines)
+        self._scrollback_spin.setSuffix(" lines")
+        behavior_layout.addRow("Scrollback buffer:", self._scrollback_spin)
+
+        self._auto_reconnect_check = QCheckBox()
+        self._auto_reconnect_check.setChecked(self._settings.auto_reconnect)
+        self._auto_reconnect_check.setToolTip("Automatically attempt to reconnect when connection is lost")
+        behavior_layout.addRow("Auto-reconnect:", self._auto_reconnect_check)
+
+        layout.addWidget(behavior_group)
+
+        # Spacer
+        layout.addStretch()
+
+        # Buttons
+        buttons = QDialogButtonBox(
+            QDialogButtonBox.StandardButton.Ok |
+            QDialogButtonBox.StandardButton.Cancel |
+            QDialogButtonBox.StandardButton.Apply
+        )
+        buttons.accepted.connect(self._on_accept)
+        buttons.rejected.connect(self._on_reject)
+        buttons.button(QDialogButtonBox.StandardButton.Apply).clicked.connect(self._apply)
+        layout.addWidget(buttons)
+
+    def _load_settings(self) -> None:
+        """Load current settings into form."""
+        # Select current theme
+        idx = self._theme_combo.findData(self._settings.theme_name)
+        if idx >= 0:
+            self._theme_combo.setCurrentIndex(idx)
+        else:
+            # Fallback to current theme
+            idx = self._theme_combo.findData(self._current_theme.name)
+            if idx >= 0:
+                self._theme_combo.setCurrentIndex(idx)
+
+        self._preview.set_theme(self._current_theme)
+        self._font_size_spin.setValue(self._settings.font_size)
+        self._multiline_spin.setValue(self._settings.multiline_paste_threshold)
+        self._scrollback_spin.setValue(self._settings.scrollback_lines)
+        self._auto_reconnect_check.setChecked(self._settings.auto_reconnect)
+
+    def _on_theme_changed(self, index: int) -> None:
+        """Handle theme selection change."""
+        theme_name = self._theme_combo.currentData()
+        theme = self.theme_engine.get_theme(theme_name)
+        if theme:
+            self._current_theme = theme
+            self._preview.set_theme(theme)
+
+    def _apply(self) -> None:
+        """Apply current settings and persist."""
+        # Update settings object
+        self._settings.theme_name = self._theme_combo.currentData()
+        self._settings.font_size = self._font_size_spin.value()
+        self._settings.multiline_paste_threshold = self._multiline_spin.value()
+        self._settings.scrollback_lines = self._scrollback_spin.value()
+        self._settings.auto_reconnect = self._auto_reconnect_check.isChecked()
+
+        # Update font size on theme
+        self._current_theme.font_size = self._font_size_spin.value()
+        self.theme_engine.current = self._current_theme
+
+        # Save to disk
+        save_settings()
+
+        # Emit signals
+        self.theme_changed.emit(self._current_theme)
+        self.settings_changed.emit(self._settings)
+
+    def _on_accept(self) -> None:
+        """Accept and close."""
+        self._apply()
+        self.accept()
+
+    def _on_reject(self) -> None:
+        """Cancel - revert to original theme."""
+        if self._current_theme != self._original_theme:
+            self.theme_engine.current = self._original_theme
+            self.theme_changed.emit(self._original_theme)
+        self.reject()
+
+    def get_theme(self) -> Theme:
+        """Get selected theme."""
+        return self._current_theme
+
+    def get_settings(self) -> AppSettings:
+        """Get current settings."""
+        return self._settings