sshmenuc 1.1.0__py3-none-any.whl

sshmenuc/__init__.py

@@ -0,0 +1,14 @@
+from .core import ConnectionManager, ConnectionNavigator, SSHLauncher
+from .ui import Colors, MenuDisplay
+from .utils import setup_logging, setup_argument_parser
+
+__version__ = "1.1.0"
+__all__ = [
+    'ConnectionManager', 
+    'ConnectionNavigator', 
+    'SSHLauncher',
+    'Colors', 
+    'MenuDisplay',
+    'setup_logging',
+    'setup_argument_parser'
+]

sshmenuc/__main__.py

@@ -0,0 +1,6 @@
+"""For execute sshmenuc as a module"""
+
+from .main import main
+
+if __name__ == "__main__":
+    main()

sshmenuc/core/__init__.py

@@ -0,0 +1,9 @@
+"""
+Core module per sshmenuc.
+"""
+from .base import BaseSSHMenuC
+from .config import ConnectionManager
+from .navigation import ConnectionNavigator
+from .launcher import SSHLauncher
+
+__all__ = ['BaseSSHMenuC', 'ConnectionManager', 'ConnectionNavigator', 'SSHLauncher']

sshmenuc/core/base.py

@@ -0,0 +1,108 @@
+"""
+Common base class for all classes in the sshmenuc project.
+Provides shared functionality and common patterns.
+"""
+import json
+import os
+import logging
+from typing import Dict, Any, List, Union, Optional
+from abc import ABC, abstractmethod
+
+
+class BaseSSHMenuC(ABC):
+    """Abstract base class with common functionality for all sshmenuc classes."""
+
+    def __init__(self, config_file: Optional[str] = None):
+        self.config_file = config_file
+        self.config_data: Dict[str, Any] = {"targets": []}
+        self._setup_logging()
+        
+    def _setup_logging(self):
+        """Setup basic logging configuration."""
+        if not logging.getLogger().handlers:
+            logging.basicConfig(level=logging.INFO)
+    
+    def load_config(self):
+        """Load and normalize the configuration file.
+
+        Handles both new format (with 'targets' key) and legacy format.
+        If the file doesn't exist or is corrupted, creates an empty config.
+        """
+        try:
+            with open(self.config_file, "r") as f:
+                data = json.load(f)
+                if isinstance(data, dict) and "targets" not in data:
+                    targets = []
+                    for k, v in data.items():
+                        targets.append({k: v})
+                    self.config_data = {"targets": targets}
+                else:
+                    self.config_data = data
+        except FileNotFoundError:
+            self._create_config_directory()
+            self.config_data = {"targets": []}
+        except json.JSONDecodeError:
+            logging.error(f"Error decoding JSON in '{self.config_file}'. Using empty configuration.")
+            self.config_data = {"targets": []}
+    
+    def _create_config_directory(self):
+        """Create configuration directory if it doesn't exist."""
+        try:
+            os.makedirs(os.path.dirname(self.config_file), exist_ok=True)
+        except Exception as e:
+            logging.warning(f"Could not create config directory: {e}")
+    
+    def save_config(self):
+        """Save configuration to file.
+
+        Raises:
+            OSError: If file cannot be written (permission denied, disk full, etc.)
+        """
+        try:
+            with open(self.config_file, "w") as file:
+                json.dump(self.config_data, file, indent=4)
+        except Exception as e:
+            logging.error(f"Error saving config: {e}")
+    
+    def get_config(self) -> Dict[str, Any]:
+        """Return the current configuration.
+
+        Returns:
+            Configuration dictionary with 'targets' key
+        """
+        return self.config_data
+    
+    def set_config(self, config_data: Dict[str, Any]):
+        """Set a new configuration.
+
+        Args:
+            config_data: New configuration dictionary to set
+        """
+        self.config_data = config_data
+    
+    def has_global_hosts(self) -> bool:
+        """Check if there are any hosts in the configuration.
+
+        Returns:
+            True if at least one host entry exists, False otherwise
+        """
+        targets = self.config_data.get("targets", [])
+        for t in targets:
+            if isinstance(t, dict):
+                for v in t.values():
+                    if isinstance(v, list):
+                        for item in v:
+                            if isinstance(item, dict) and ("friendly" in item or "host" in item):
+                                return True
+        return False
+    
+    @abstractmethod
+    def validate_config(self) -> bool:
+        """Abstract method to validate the configuration.
+
+        Must be implemented by subclasses to provide specific validation logic.
+
+        Returns:
+            True if configuration is valid, False otherwise
+        """
+        pass

sshmenuc/core/config.py

@@ -0,0 +1,146 @@
+"""
+SSH configuration management.
+"""
+from typing import List, Dict, Any, Optional
+from .base import BaseSSHMenuC
+
+
+class ConnectionManager(BaseSSHMenuC):
+    """Manages SSH connection configurations.
+
+    Provides CRUD operations for targets and connections within the configuration.
+    """
+
+    def __init__(self, config_file: Optional[str] = None):
+        super().__init__(config_file)
+        if config_file:
+            self.load_config()
+
+    def _get_target_key(self, target: Dict[str, Any]) -> str:
+        """Extract the first (and only) key from a target dictionary.
+
+        Args:
+            target: Target dictionary with single key
+
+        Returns:
+            The target key name
+        """
+        return next(iter(target.keys()))
+
+    def _find_target(self, target_name: str) -> Optional[Dict[str, Any]]:
+        """Find and return the target dictionary by name.
+
+        Args:
+            target_name: Name of the target to find
+
+        Returns:
+            Target dictionary if found, None otherwise
+        """
+        for target in self.config_data["targets"]:
+            if self._get_target_key(target) == target_name:
+                return target
+        return None
+
+    def validate_config(self) -> bool:
+        """Validate the configuration structure.
+
+        Returns:
+            True if config has valid structure with 'targets' key, False otherwise
+        """
+        if not isinstance(self.config_data, dict):
+            return False
+        if "targets" not in self.config_data:
+            return False
+        if not isinstance(self.config_data["targets"], list):
+            return False
+        return True
+    
+    def create_target(self, target_name: str, connections: List[Dict[str, Any]]):
+        """Create a new connection target.
+
+        Args:
+            target_name: Name of the target to create
+            connections: List of connection configuration dictionaries
+        """
+        target = {target_name: connections}
+        self.config_data["targets"].append(target)
+    
+    def modify_target(self, target_name: str, new_target_name: str = None,
+                     connections: List[Dict[str, Any]] = None):
+        """Modify an existing target.
+
+        Args:
+            target_name: Current name of the target
+            new_target_name: New name for the target (optional, if renaming)
+            connections: New connection list (optional, if updating connections)
+        """
+        target = self._find_target(target_name)
+        if target:
+            if new_target_name:
+                target[new_target_name] = target.pop(target_name)
+            if connections:
+                key = self._get_target_key(target)
+                target[key] = connections
+    
+    def delete_target(self, target_name: str):
+        """Delete a target.
+
+        Args:
+            target_name: Name of the target to delete
+        """
+        self.config_data["targets"] = [
+            target for target in self.config_data["targets"]
+            if self._get_target_key(target) != target_name
+        ]
+    
+    def create_connection(self, target_name: str, friendly: str, host: str,
+                         connection_type: str = "ssh", command: str = "ssh",
+                         zone: str = "", project: str = ""):
+        """Create a new connection within a target.
+
+        Args:
+            target_name: Name of the target to add connection to
+            friendly: Friendly name for the connection
+            host: Host address to connect to
+            connection_type: Type of connection (ssh, gssh, docker)
+            command: Command to execute for connection
+            zone: Cloud zone (for gssh connections)
+            project: Cloud project (for gssh connections)
+        """
+        connection = {
+            "friendly": friendly,
+            "host": host,
+            "connection_type": connection_type,
+            "command": command,
+            "zone": zone,
+            "project": project,
+        }
+        target = self._find_target(target_name)
+        if target:
+            target[target_name].append(connection)
+    
+    def modify_connection(self, target_name: str, connection_index: int, **kwargs):
+        """Modify an existing connection.
+
+        Args:
+            target_name: Name of the target containing the connection
+            connection_index: Index of the connection to modify
+            **kwargs: Connection fields to update (host, user, certkey, etc.)
+        """
+        target = self._find_target(target_name)
+        if target:
+            connection = target[target_name][connection_index]
+            for key, value in kwargs.items():
+                if value is not None:
+                    connection[key] = value
+    
+    def delete_connection(self, target_name: str, connection_index: int):
+        """Delete a connection.
+
+        Args:
+            target_name: Name of the target containing the connection
+            connection_index: Index of the connection to delete
+        """
+        target = self._find_target(target_name)
+        if target:
+            target[target_name].pop(connection_index)

sshmenuc/core/config_editor.py

@@ -0,0 +1,217 @@
+"""
+Interactive configuration editor for managing targets and connections.
+"""
+from typing import Dict, Any, Optional
+from clint.textui import puts, colored
+from .config import ConnectionManager
+
+
+class ConfigEditor:
+    """Interactive editor for SSH configuration.
+
+    Provides forms and dialogs for creating, editing, and deleting
+    targets and connections within the configuration.
+    """
+
+    def __init__(self, config_manager: ConnectionManager):
+        """Initialize the config editor.
+
+        Args:
+            config_manager: ConnectionManager instance to modify
+        """
+        self.manager = config_manager
+
+    def prompt_input(self, prompt: str, default: str = "") -> str:
+        """Prompt user for input with optional default value.
+
+        Args:
+            prompt: Prompt message to display
+            default: Default value if user presses enter
+
+        Returns:
+            User input string
+        """
+        if default:
+            result = input(f"{prompt} [{default}]: ").strip()
+            return result if result else default
+        return input(f"{prompt}: ").strip()
+
+    def confirm(self, message: str) -> bool:
+        """Ask user for confirmation.
+
+        Args:
+            message: Confirmation message
+
+        Returns:
+            True if user confirms, False otherwise
+        """
+        response = input(f"{message} [y/N]: ").strip().lower()
+        return response == 'y'
+
+    def add_target(self) -> bool:
+        """Interactive form to add a new target.
+
+        Returns:
+            True if target was added, False if cancelled
+        """
+        puts(colored.cyan("\n=== Add New Target ==="))
+        target_name = self.prompt_input("Target name (e.g., Production, Development)")
+
+        if not target_name:
+            puts(colored.red("Target name cannot be empty"))
+            return False
+
+        # Check if target already exists
+        if self.manager._find_target(target_name):
+            puts(colored.red(f"Target '{target_name}' already exists"))
+            return False
+
+        self.manager.create_target(target_name, [])
+        self.manager.save_config()
+        puts(colored.green(f"✓ Target '{target_name}' created successfully"))
+        return True
+
+    def delete_target(self, target_name: str) -> bool:
+        """Delete a target with confirmation.
+
+        Args:
+            target_name: Name of target to delete
+
+        Returns:
+            True if deleted, False if cancelled
+        """
+        if not self.confirm(f"Delete target '{target_name}' and all its connections?"):
+            puts(colored.yellow("Cancelled"))
+            return False
+
+        self.manager.delete_target(target_name)
+        self.manager.save_config()
+        puts(colored.green(f"✓ Target '{target_name}' deleted"))
+        return True
+
+    def rename_target(self, target_name: str) -> bool:
+        """Rename a target.
+
+        Args:
+            target_name: Current name of target
+
+        Returns:
+            True if renamed, False if cancelled
+        """
+        puts(colored.cyan(f"\n=== Rename Target '{target_name}' ==="))
+        new_name = self.prompt_input("New name", target_name)
+
+        if not new_name or new_name == target_name:
+            puts(colored.yellow("Cancelled"))
+            return False
+
+        # Check if new name already exists
+        if self.manager._find_target(new_name):
+            puts(colored.red(f"Target '{new_name}' already exists"))
+            return False
+
+        self.manager.modify_target(target_name, new_target_name=new_name)
+        self.manager.save_config()
+        puts(colored.green(f"✓ Target renamed to '{new_name}'"))
+        return True
+
+    def add_connection(self, target_name: str) -> bool:
+        """Interactive form to add a connection to a target.
+
+        Args:
+            target_name: Target to add connection to
+
+        Returns:
+            True if connection added, False if cancelled
+        """
+        puts(colored.cyan(f"\n=== Add Connection to '{target_name}' ==="))
+
+        friendly = self.prompt_input("Friendly name (display name)")
+        if not friendly:
+            puts(colored.red("Friendly name cannot be empty"))
+            return False
+
+        host = self.prompt_input("Host (IP or hostname)")
+        if not host:
+            puts(colored.red("Host cannot be empty"))
+            return False
+
+        user = self.prompt_input("Username (optional, leave empty for current user)", "")
+        certkey = self.prompt_input("SSH key path (optional)", "")
+        connection_type = self.prompt_input("Connection type", "ssh")
+
+        # Build connection dict with only non-empty fields
+        connection = {
+            "friendly": friendly,
+            "host": host,
+            "connection_type": connection_type,
+        }
+
+        if user:
+            connection["user"] = user
+        if certkey:
+            connection["certkey"] = certkey
+
+        # Add connection using the existing method
+        target = self.manager._find_target(target_name)
+        if target:
+            target[target_name].append(connection)
+            self.manager.save_config()
+            puts(colored.green(f"✓ Connection '{friendly}' added to '{target_name}'"))
+            return True
+
+        puts(colored.red(f"Target '{target_name}' not found"))
+        return False
+
+    def edit_connection(self, target_name: str, connection_index: int,
+                       connection: Dict[str, Any]) -> bool:
+        """Interactive form to edit a connection.
+
+        Args:
+            target_name: Target containing the connection
+            connection_index: Index of connection to edit
+            connection: Current connection data
+
+        Returns:
+            True if edited, False if cancelled
+        """
+        puts(colored.cyan(f"\n=== Edit Connection '{connection.get('friendly', 'Unknown')}' ==="))
+
+        friendly = self.prompt_input("Friendly name", connection.get("friendly", ""))
+        host = self.prompt_input("Host", connection.get("host", ""))
+        user = self.prompt_input("Username", connection.get("user", ""))
+        certkey = self.prompt_input("SSH key path", connection.get("certkey", ""))
+
+        if not friendly or not host:
+            puts(colored.red("Friendly name and host cannot be empty"))
+            return False
+
+        self.manager.modify_connection(
+            target_name, connection_index,
+            friendly=friendly, host=host, user=user or None, certkey=certkey or None
+        )
+        self.manager.save_config()
+        puts(colored.green(f"✓ Connection updated"))
+        return True
+
+    def delete_connection(self, target_name: str, connection_index: int,
+                         connection: Dict[str, Any]) -> bool:
+        """Delete a connection with confirmation.
+
+        Args:
+            target_name: Target containing the connection
+            connection_index: Index of connection to delete
+            connection: Connection data (for display)
+
+        Returns:
+            True if deleted, False if cancelled
+        """
+        friendly = connection.get("friendly", "Unknown")
+        if not self.confirm(f"Delete connection '{friendly}'?"):
+            puts(colored.yellow("Cancelled"))
+            return False
+
+        self.manager.delete_connection(target_name, connection_index)
+        self.manager.save_config()
+        puts(colored.green(f"✓ Connection '{friendly}' deleted"))
+        return True