ntermqt 0.1.0__py3-none-any.whl

nterm/vault/credential_manager.py

@@ -0,0 +1,163 @@
+#!/usr/bin/env python3
+"""
+Example: Credential Manager with Theme Integration
+
+Shows how to use the credential manager with nterm's theme system.
+"""
+
+import sys
+from pathlib import Path
+
+from PyQt6.QtWidgets import (
+    QApplication, QMainWindow, QWidget, QVBoxLayout,
+    QHBoxLayout, QComboBox, QLabel, QPushButton,
+)
+from PyQt6.QtCore import Qt
+
+# Add parent to path for imports
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from nterm.vault import CredentialManagerWidget, CredentialResolver, ManagerTheme
+from nterm.theme import Theme, ThemeEngine
+
+
+class CredentialManagerWindow(QMainWindow):
+    """Main window with theme-aware credential manager."""
+    
+    def __init__(self):
+        super().__init__()
+        self.setWindowTitle("nTerm Credential Manager")
+        self.setMinimumSize(900, 700)
+        
+        # Initialize theme engine
+        self.theme_engine = ThemeEngine()
+        self.theme_engine.load_themes()
+        
+        # Initialize credential resolver (includes store)
+        self.resolver = CredentialResolver()
+        
+        # Setup UI
+        self._setup_ui()
+        
+        # Apply default theme
+        self._apply_theme(self.theme_engine.current)
+        
+        # Try auto-unlock from keychain
+        self.manager.try_auto_unlock()
+    
+    def _setup_ui(self):
+        central = QWidget()
+        self.setCentralWidget(central)
+        
+        layout = QVBoxLayout(central)
+        layout.setContentsMargins(0, 0, 0, 0)
+        layout.setSpacing(0)
+        
+        # Theme selector bar
+        theme_bar = QWidget()
+        theme_bar.setObjectName("themeBar")
+        theme_layout = QHBoxLayout(theme_bar)
+        theme_layout.setContentsMargins(16, 8, 16, 8)
+        
+        theme_layout.addWidget(QLabel("Theme:"))
+        
+        self.theme_combo = QComboBox()
+        self.theme_combo.addItems(self.theme_engine.list_themes())
+        self.theme_combo.setCurrentText("default")
+        self.theme_combo.currentTextChanged.connect(self._on_theme_changed)
+        theme_layout.addWidget(self.theme_combo)
+        
+        theme_layout.addStretch()
+        
+        # Keychain management
+        from nterm.vault import KeychainIntegration
+        if KeychainIntegration.is_available():
+            clear_keychain_btn = QPushButton("Clear Keychain Password")
+            clear_keychain_btn.clicked.connect(self._clear_keychain)
+            theme_layout.addWidget(clear_keychain_btn)
+        
+        layout.addWidget(theme_bar)
+        
+        # Credential manager
+        self.manager = CredentialManagerWidget(store=self.resolver.store)
+        self.manager.credential_selected.connect(self._on_credential_selected)
+        self.manager.vault_unlocked.connect(self._on_vault_unlocked)
+        self.manager.vault_locked.connect(self._on_vault_locked)
+        layout.addWidget(self.manager)
+    
+    def _apply_theme(self, theme: Theme):
+        """Apply theme to entire window."""
+        self.theme_engine.current = theme
+        
+        # Apply to credential manager
+        self.manager.set_theme(theme)
+        
+        # Style the theme bar to match
+        self.setStyleSheet(f"""
+            QMainWindow {{
+                background-color: {theme.background_color};
+            }}
+            #themeBar {{
+                background-color: {theme.terminal_colors.get('black', '#313244')};
+                border-bottom: 1px solid {theme.border_color};
+            }}
+            #themeBar QLabel {{
+                color: {theme.foreground_color};
+                font-family: {theme.font_family};
+            }}
+            #themeBar QComboBox {{
+                background-color: {theme.background_color};
+                color: {theme.foreground_color};
+                border: 1px solid {theme.border_color};
+                border-radius: 4px;
+                padding: 4px 8px;
+                min-width: 120px;
+            }}
+            #themeBar QPushButton {{
+                background-color: {theme.background_color};
+                color: {theme.foreground_color};
+                border: 1px solid {theme.border_color};
+                border-radius: 4px;
+                padding: 4px 12px;
+            }}
+            #themeBar QPushButton:hover {{
+                border-color: {theme.accent_color};
+            }}
+        """)
+    
+    def _on_theme_changed(self, theme_name: str):
+        theme = self.theme_engine.get_theme(theme_name)
+        if theme:
+            self._apply_theme(theme)
+    
+    def _on_credential_selected(self, name: str):
+        print(f"Selected credential: {name}")
+    
+    def _on_vault_unlocked(self):
+        print("Vault unlocked")
+    
+    def _on_vault_locked(self):
+        print("Vault locked")
+    
+    def _clear_keychain(self):
+        from nterm.vault import KeychainIntegration
+        if KeychainIntegration.clear_master_password():
+            from PyQt6.QtWidgets import QMessageBox
+            QMessageBox.information(self, "Success", "Keychain password cleared")
+        else:
+            from PyQt6.QtWidgets import QMessageBox
+            QMessageBox.warning(self, "Error", "Failed to clear keychain")
+
+
+def main():
+    app = QApplication(sys.argv)
+    app.setStyle("Fusion")
+    
+    window = CredentialManagerWindow()
+    window.show()
+    
+    sys.exit(app.exec())
+
+
+if __name__ == "__main__":
+    main()

nterm/vault/keychain.py

@@ -0,0 +1,135 @@
+"""
+Cross-platform keychain integration for master password storage.
+
+Supports:
+- macOS: Keychain
+- Windows: Credential Locker
+- Linux: Secret Service (GNOME Keyring / KWallet)
+"""
+
+from __future__ import annotations
+import logging
+from typing import Optional
+
+logger = logging.getLogger(__name__)
+
+# Try to import keyring - it's optional
+try:
+    import keyring
+    from keyring.errors import PasswordDeleteError, KeyringError
+    KEYRING_AVAILABLE = True
+except ImportError:
+    KEYRING_AVAILABLE = False
+    logger.debug("keyring not available - install with: pip install keyring")
+
+
+class KeychainIntegration:
+    """
+    Optional system keychain integration for master password caching.
+    
+    This doesn't replace the vault's encryption - it just caches the
+    master password so users don't have to type it every session.
+    """
+    
+    SERVICE_NAME = "nterm-vault"
+    ACCOUNT_NAME = "master-password"
+    
+    @classmethod
+    def is_available(cls) -> bool:
+        """Check if system keychain is available and functional."""
+        if not KEYRING_AVAILABLE:
+            return False
+        
+        try:
+            # Probe the keychain backend
+            backend = keyring.get_keyring()
+            # Check it's not the fail backend
+            backend_name = type(backend).__name__
+            if "Fail" in backend_name or "Null" in backend_name:
+                logger.debug(f"Keyring backend not usable: {backend_name}")
+                return False
+            logger.debug(f"Keyring backend: {backend_name}")
+            return True
+        except Exception as e:
+            logger.debug(f"Keyring probe failed: {e}")
+            return False
+    
+    @classmethod
+    def get_backend_name(cls) -> Optional[str]:
+        """Get the name of the active keyring backend."""
+        if not KEYRING_AVAILABLE:
+            return None
+        try:
+            return type(keyring.get_keyring()).__name__
+        except Exception:
+            return None
+    
+    @classmethod
+    def store_master_password(cls, password: str) -> bool:
+        """
+        Store master password in system keychain.
+        
+        Args:
+            password: The master vault password
+            
+        Returns:
+            True if stored successfully
+        """
+        if not cls.is_available():
+            logger.warning("Keychain not available")
+            return False
+        
+        try:
+            keyring.set_password(cls.SERVICE_NAME, cls.ACCOUNT_NAME, password)
+            logger.info("Master password stored in system keychain")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to store password in keychain: {e}")
+            return False
+    
+    @classmethod
+    def get_master_password(cls) -> Optional[str]:
+        """
+        Retrieve master password from system keychain.
+        
+        Returns:
+            Password if found, None otherwise
+        """
+        if not KEYRING_AVAILABLE:
+            return None
+        
+        try:
+            password = keyring.get_password(cls.SERVICE_NAME, cls.ACCOUNT_NAME)
+            if password:
+                logger.debug("Retrieved master password from keychain")
+            return password
+        except Exception as e:
+            logger.debug(f"Failed to get password from keychain: {e}")
+            return None
+    
+    @classmethod
+    def clear_master_password(cls) -> bool:
+        """
+        Remove master password from system keychain.
+        
+        Returns:
+            True if removed (or wasn't present)
+        """
+        if not KEYRING_AVAILABLE:
+            return False
+        
+        try:
+            keyring.delete_password(cls.SERVICE_NAME, cls.ACCOUNT_NAME)
+            logger.info("Master password removed from system keychain")
+            return True
+        except PasswordDeleteError:
+            # Password wasn't stored - that's fine
+            return True
+        except Exception as e:
+            logger.error(f"Failed to remove password from keychain: {e}")
+            return False
+    
+    @classmethod
+    def has_stored_password(cls) -> bool:
+        """Check if a password is stored without retrieving it."""
+        return cls.get_master_password() is not None