sshplex 1.0.0__py3-none-any.whl

sshplex/__init__.py

@@ -0,0 +1,4 @@
+"""SSHplex - SSH Connection Multiplexer"""
+__version__ = "1.0.0"
+__author__ = "MJAHED Sabri"
+__email__ = "contact@sabrimjahed.com"

sshplex/cli.py

@@ -0,0 +1,103 @@
+"""CLI debug interface for SSHplex (for pip-installed package)"""
+
+import sys
+import argparse
+from typing import Any
+
+from .lib.config import load_config
+from .lib.logger import setup_logging, get_logger
+from .lib.sot.netbox import NetBoxProvider
+
+
+def main() -> int:
+    """CLI debug entry point for installed SSHplex package."""
+
+    try:
+        # Parse command line arguments
+        parser = argparse.ArgumentParser(description="SSHplex CLI: Debug interface for NetBox connectivity testing.")
+        parser.add_argument('--config', type=str, default=None, help='Path to the configuration file (default: ~/.config/sshplex/sshplex.yaml)')
+        parser.add_argument('--version', action='version', version='SSHplex 1.0.0')
+        args = parser.parse_args()
+
+        # Load configuration (will use default path if none specified)
+        print("SSHplex CLI Debug Mode - Loading configuration...")
+        config = load_config(args.config)
+
+        # Setup logging
+        setup_logging(
+            log_level=config.logging.level,
+            log_file=config.logging.file,
+            enabled=config.logging.enabled
+        )
+
+        logger = get_logger()
+        logger.info("SSHplex CLI debug mode started")
+
+        return debug_mode(config, logger)
+
+    except FileNotFoundError as e:
+        print(f"Error: {e}")
+        print("Please ensure config.yaml exists and is properly configured")
+        print("Note: This is the CLI debug interface. For the full TUI application,")
+        print("run the main sshplex.py script from the source repository.")
+        return 1
+    except ValueError as e:
+        print(f"Configuration Error: {e}")
+        return 1
+    except KeyboardInterrupt:
+        print("\nSSHplex CLI interrupted by user")
+        return 1
+    except Exception as e:
+        print(f"Unexpected error: {e}")
+        return 1
+
+
+def debug_mode(config: Any, logger: Any) -> int:
+    """Run debug mode - NetBox connection and host listing test."""
+    logger.info("Running CLI debug mode - NetBox connectivity test")
+
+    # Initialize NetBox provider
+    logger.info("Initializing NetBox provider")
+    netbox = NetBoxProvider(
+        url=config.netbox.url,
+        token=config.netbox.token,
+        verify_ssl=config.netbox.verify_ssl,
+        timeout=config.netbox.timeout
+    )
+
+    # Test connection
+    logger.info("Testing NetBox connection...")
+    if not netbox.connect():
+        logger.error("Failed to connect to NetBox")
+        print("❌ Failed to connect to NetBox")
+        print("Check your configuration and network connectivity")
+        return 1
+
+    print("✅ Successfully connected to NetBox")
+
+    # Retrieve VMs with filters
+    logger.info("Retrieving VMs from NetBox...")
+    hosts = netbox.get_hosts(filters=config.netbox.default_filters)
+
+    # Display results
+    if hosts:
+        logger.info(f"Successfully retrieved {len(hosts)} VMs")
+        print(f"\n📋 Found {len(hosts)} hosts matching filters:")
+        print("-" * 60)
+        for i, host in enumerate(hosts, 1):
+            status = host.metadata.get('status', 'unknown')
+            print(f"{i:3d}. {host.name:<30} {host.ip:<15} [{status}]")
+        print("-" * 60)
+    else:
+        logger.warning("No VMs found matching the filters")
+        print("⚠️  No hosts found matching the configured filters")
+        print("Check your NetBox filters in the configuration")
+
+    logger.info("SSHplex CLI debug mode completed successfully")
+    print(f"\n✅ CLI debug mode completed successfully")
+    print("Note: For the full TUI interface, run the main application")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

sshplex/config-template.yaml

@@ -0,0 +1,35 @@
+# SSHplex Configuration - Phase 2 with tmux support
+sshplex:
+  version: "1.0.0"
+  session_prefix: "sshplex"
+
+netbox:
+  url: "https://netbox.lan/"
+  token: "CHANGE_TOKEN_HERE"
+  verify_ssl: false
+  timeout: 30
+  default_filters:
+    status: "active"
+    role: "virtual-machine"
+    has_primary_ip: "true"
+
+ssh:
+  username: "admin"
+  key_path: "~/.ssh/id_ed25519"
+  timeout: 10
+  port: 22
+
+tmux:
+  layout: "tiled" # tiled, even-horizontal, even-vertical
+  broadcast: false # Start with broadcast off
+  window_name: "sshplex"
+
+ui:
+  show_log_panel: false
+  log_panel_height: 20
+  table_columns: ["name", "ip", "cluster", "tags", "description"]
+
+logging:
+  enabled: false
+  level: "DEBUG" # DEBUG, INFO, WARNING, ERROR
+  file: "logs/sshplex.log"

sshplex/lib/__init__.py

@@ -0,0 +1 @@
+# The logs directory is intentionally left blank.

sshplex/lib/config.py

@@ -0,0 +1,196 @@
+"""SSHplex configuration management with pydantic validation - Phase 3."""
+
+from pathlib import Path
+from typing import Dict, Any, Optional
+import yaml
+import shutil
+import os
+from pydantic import BaseModel, Field, validator
+
+
+class SSHplexConfig(BaseModel):
+    """SSHplex main configuration."""
+    version: str = "1.0.0"
+    session_prefix: str = "sshplex"
+
+
+class NetBoxConfig(BaseModel):
+    """NetBox connection configuration."""
+    url: str = Field(..., description="NetBox instance URL")
+    token: str = Field(..., description="NetBox API token")
+    verify_ssl: bool = True
+    timeout: int = 30
+    default_filters: Dict[str, str] = Field(default_factory=dict)
+
+    @validator('url')
+    def validate_url(cls, v: str) -> str:
+        """Validate NetBox URL format."""
+        if not v.startswith(('http://', 'https://')):
+            raise ValueError('NetBox URL must start with http:// or https://')
+        return v
+
+
+class LoggingConfig(BaseModel):
+    """Logging configuration."""
+    enabled: bool = True
+    level: str = "INFO"
+    file: str = "logs/sshplex.log"
+
+    @validator('level')
+    def validate_level(cls, v: str) -> str:
+        """Validate logging level."""
+        valid_levels = ["DEBUG", "INFO", "WARNING", "ERROR"]
+        if v.upper() not in valid_levels:
+            raise ValueError(f'Log level must be one of: {valid_levels}')
+        return v.upper()
+
+
+class UIConfig(BaseModel):
+    """User interface configuration."""
+    show_log_panel: bool = True
+    log_panel_height: int = 20  # Percentage of screen height
+    table_columns: list = Field(default_factory=lambda: ["name", "ip", "cluster", "role", "tags"])
+
+
+class SSHConfig(BaseModel):
+    """SSH connection configuration."""
+    username: str = Field(default="admin", description="Default SSH username")
+    key_path: str = Field(default="~/.ssh/id_rsa", description="Path to SSH private key")
+    timeout: int = 10
+    port: int = 22
+
+
+class TmuxConfig(BaseModel):
+    """tmux configuration."""
+    layout: str = "tiled"  # tiled, even-horizontal, even-vertical
+    broadcast: bool = False  # Start with broadcast off
+    window_name: str = "sshplex"
+
+
+class Config(BaseModel):
+    """Main SSHplex configuration model."""
+    sshplex: SSHplexConfig = Field(default_factory=SSHplexConfig)
+    netbox: NetBoxConfig
+    ssh: SSHConfig = Field(default_factory=SSHConfig)
+    tmux: TmuxConfig = Field(default_factory=TmuxConfig)
+    logging: LoggingConfig = Field(default_factory=LoggingConfig)
+    ui: UIConfig = Field(default_factory=UIConfig)
+
+
+def get_default_config_path() -> Path:
+    """Get the default configuration file path in ~/.config/sshplex/sshplex.yaml"""
+    return Path.home() / ".config" / "sshplex" / "sshplex.yaml"
+
+
+def get_template_config_path() -> Path:
+    """Get the path to the config template file."""
+    # Get the directory where this config.py file is located
+    lib_dir = Path(__file__).parent
+    # Go up to sshplex directory and find config-template.yaml
+    sshplex_dir = lib_dir.parent
+    return sshplex_dir / "config-template.yaml"
+
+
+def ensure_config_directory() -> Path:
+    """Ensure the ~/.config/sshplex directory exists."""
+    config_dir = Path.home() / ".config" / "sshplex"
+    config_dir.mkdir(parents=True, exist_ok=True)
+    return config_dir
+
+
+def initialize_default_config() -> Path:
+    """Initialize default configuration by copying template to ~/.config/sshplex/sshplex.yaml"""
+    from .logger import get_logger
+
+    logger = get_logger()
+    config_path = get_default_config_path()
+    template_path = get_template_config_path()
+
+    # Ensure config directory exists
+    ensure_config_directory()
+
+    if not template_path.exists():
+        raise FileNotFoundError(f"SSHplex: Template config file not found: {template_path}")
+
+    # Copy template to default config location
+    shutil.copy2(template_path, config_path)
+    logger.info(f"SSHplex: Created default configuration at {config_path}")
+    logger.info(f"SSHplex: Please edit {config_path} with your NetBox details")
+
+    return config_path
+
+
+def load_config(config_path: Optional[str] = None) -> Config:
+    """Load and validate configuration from YAML file.
+
+    Phase 3: Uses ~/.config/sshplex/sshplex.yaml as default location.
+    Creates config directory and copies template on first run.
+
+    Args:
+        config_path: Path to configuration file (optional, defaults to ~/.config/sshplex/sshplex.yaml)
+
+    Returns:
+        Validated configuration object
+
+    Raises:
+        FileNotFoundError: If config file doesn't exist and template can't be found
+        ValueError: If config validation fails
+    """
+    from .logger import get_logger
+
+    # Use default config path if none provided
+    if config_path is None:
+        config_file = get_default_config_path()
+
+        # If default config doesn't exist, initialize it from template
+        if not config_file.exists():
+            try:
+                config_file = initialize_default_config()
+                print(f"✅ SSHplex: First run detected - created configuration at {config_file}")
+                print(f"📝 Please edit {config_file} with your NetBox details before running SSHplex again")
+                print(f"🔧 Key settings to configure:")
+                print(f"   - netbox.url: Your NetBox instance URL")
+                print(f"   - netbox.token: Your NetBox API token")
+                print(f"   - ssh.username: Your SSH username")
+                print(f"   - ssh.key_path: Path to your SSH private key")
+                print(f"\n🚀 Run 'sshplex' again after configuration is complete!")
+                # Exit gracefully to let user configure
+                import sys
+                sys.exit(0)
+            except Exception as e:
+                raise FileNotFoundError(f"SSHplex: Could not initialize default config: {e}")
+    else:
+        config_file = Path(config_path)
+
+    if not config_file.exists():
+        raise FileNotFoundError(f"SSHplex: Configuration file not found: {config_file}")
+
+    try:
+        logger = get_logger()
+        logger.info(f"SSHplex: Loading configuration from {config_file}")
+
+        with open(config_file, 'r') as f:
+            config_data = yaml.safe_load(f)
+
+        config = Config(**config_data)
+        logger.info("SSHplex: Configuration loaded and validated successfully")
+        return config
+
+    except yaml.YAMLError as e:
+        raise ValueError(f"SSHplex: Invalid YAML in config file: {e}")
+    except Exception as e:
+        raise ValueError(f"SSHplex: Configuration validation failed: {e}")
+
+
+def get_config_info() -> Dict[str, Any]:
+    """Get information about SSHplex configuration paths and status."""
+    default_path = get_default_config_path()
+    template_path = get_template_config_path()
+
+    return {
+        "default_config_path": str(default_path),
+        "default_config_exists": default_path.exists(),
+        "template_path": str(template_path),
+        "template_exists": template_path.exists(),
+        "config_dir_exists": default_path.parent.exists()
+    }

sshplex/lib/logger.py

@@ -0,0 +1,54 @@
+"""SSHplex logging configuration using loguru."""
+
+import os
+from pathlib import Path
+from typing import Any
+from loguru import logger
+
+
+def setup_logging(log_level: str = "INFO", log_file: str = "logs/sshplex.log", enabled: bool = True) -> None:
+    """Set up logging for SSHplex with file rotation.
+
+    Args:
+        log_level: Logging level (DEBUG, INFO, WARNING, ERROR)
+        log_file: Path to log file
+        enabled: Whether logging is enabled (if False, only console errors will be shown)
+    """
+    # Remove default logger
+    logger.remove()
+
+    if not enabled:
+        # When logging is disabled, only show ERROR and CRITICAL messages to console
+        logger.add(
+            sink=lambda msg: print(msg, end=""),
+            level="ERROR",
+            format="<red>ERROR</red> | <cyan>SSHplex</cyan> | {message}"
+        )
+        return
+
+    # Create logs directory if it doesn't exist
+    log_path = Path(log_file)
+    log_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Add console logging
+    logger.add(
+        sink=lambda msg: print(msg, end=""),
+        level=log_level,
+        format="<green>{time:HH:mm:ss}</green> | <level>{level: <8}</level> | <cyan>SSHplex</cyan> | {message}"
+    )
+
+    # Add file logging with rotation
+    logger.add(
+        log_file,
+        rotation="10 MB",
+        retention="30 days",
+        level=log_level,
+        format="{time:YYYY-MM-DD HH:mm:ss} | {level} | {module}:{line} | SSHplex | {message}"
+    )
+
+    logger.info(f"SSHplex logging initialized - Level: {log_level}, File: {log_file}")
+
+
+def get_logger() -> Any:
+    """Get the configured logger instance."""
+    return logger

sshplex/lib/multiplexer/__init__.py

@@ -0,0 +1 @@
+# The logs directory is intentionally left blank.

sshplex/lib/multiplexer/base.py

@@ -0,0 +1,48 @@
+"""Base class for terminal multiplexers in SSHplex."""
+
+from abc import ABC, abstractmethod
+from typing import List, Dict, Any, Optional
+
+
+class MultiplexerBase(ABC):
+    """Abstract base class for terminal multiplexers."""
+
+    def __init__(self, session_name: str):
+        """Initialize the multiplexer with a session name."""
+        self.session_name = session_name
+        self.panes: Dict[str, Any] = {}
+
+    @abstractmethod
+    def create_session(self) -> bool:
+        """Create a new multiplexer session."""
+        pass
+
+    @abstractmethod
+    def create_pane(self, hostname: str, command: Optional[str] = None) -> bool:
+        """Create a new pane for the given hostname."""
+        pass
+
+    @abstractmethod
+    def set_pane_title(self, pane_id: str, title: str) -> bool:
+        """Set the title of a specific pane."""
+        pass
+
+    @abstractmethod
+    def send_command(self, pane_id: str, command: str) -> bool:
+        """Send a command to a specific pane."""
+        pass
+
+    @abstractmethod
+    def broadcast_command(self, command: str) -> bool:
+        """Send a command to all panes."""
+        pass
+
+    @abstractmethod
+    def close_session(self) -> None:
+        """Close the multiplexer session."""
+        pass
+
+    @abstractmethod
+    def attach_to_session(self) -> None:
+        """Attach to the multiplexer session."""
+        pass

sshplex/lib/multiplexer/tmux.py

@@ -0,0 +1,227 @@
+"""SSHplex tmux multiplexer implementation."""
+
+import libtmux
+from typing import Optional, Dict
+from datetime import datetime
+
+from .base import MultiplexerBase
+from ..logger import get_logger
+
+
+class TmuxManager(MultiplexerBase):
+    """tmux implementation for SSHplex multiplexer."""
+
+    def __init__(self, session_name: Optional[str] = None):
+        """Initialize tmux manager with session name."""
+        if session_name is None:
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            session_name = f"sshplex-{timestamp}"
+
+        super().__init__(session_name)
+        self.logger = get_logger()
+        self.server = libtmux.Server()
+        self.session: Optional[libtmux.Session] = None
+        self.window: Optional[libtmux.Window] = None
+        self.panes: Dict[str, libtmux.Pane] = {}
+
+    def create_session(self) -> bool:
+        """Create a new tmux session with SSHplex branding."""
+        try:
+            self.logger.info(f"SSHplex: Creating tmux session '{self.session_name}'")
+
+            # Check if session already exists
+            if self.server.has_session(self.session_name):
+                self.logger.warning(f"SSHplex: Session '{self.session_name}' already exists")
+                self.session = self.server.sessions.get(session_name=self.session_name)
+            else:
+                # Create new session
+                self.session = self.server.new_session(
+                    session_name=self.session_name,
+                    window_name="sshplex",
+                    start_directory="~"
+                )
+
+            # Get the main window
+            if self.session:
+                self.window = self.session.attached_window
+                self.logger.info(f"SSHplex: tmux session '{self.session_name}' created successfully")
+                return True
+            else:
+                return False
+
+        except Exception as e:
+            self.logger.error(f"SSHplex: Failed to create tmux session: {e}")
+            return False
+
+    def create_pane(self, hostname: str, command: Optional[str] = None) -> bool:
+        """Create a new pane for the given hostname."""
+        try:
+            if self.session is None or self.window is None:
+                if not self.create_session():
+                    return False
+
+            self.logger.info(f"SSHplex: Creating pane for host '{hostname}'")
+
+            # Split window to create new pane (except for the first pane)
+            if self.window is None:
+                self.logger.error("SSHplex: No window available for pane creation")
+                return False
+
+            if len(self.panes) == 0:
+                # First pane - use the existing window pane
+                pane = self.window.attached_pane
+                if pane is None:
+                    raise RuntimeError(f"No attached pane available for {hostname}")
+            else:
+                # Additional panes - split the window
+                pane = self.window.split_window()
+                if pane is None:
+                    raise RuntimeError(f"Failed to create tmux pane for {hostname}")
+
+            # Store pane reference
+            self.panes[hostname] = pane
+
+            # Set pane title
+            self.set_pane_title(hostname, hostname)
+
+            # Execute the provided command (should be SSH command)
+            if command:
+                self.send_command(hostname, command)
+
+            self.logger.info(f"SSHplex: Pane created for '{hostname}' successfully")
+            return True
+
+        except Exception as e:
+            self.logger.error(f"SSHplex: Failed to create pane for '{hostname}': {e}")
+            return False
+
+    def create_window(self, hostname: str, command: Optional[str] = None) -> bool:
+        """Create a new window (tab) in the tmux session and execute a command."""
+        try:
+            if not self.session:
+                self.logger.error("SSHplex: No active tmux session for window creation")
+                return False
+
+            # Create new window with hostname as the window name
+            window = self.session.new_window(window_name=hostname)
+
+            if not window:
+                self.logger.error(f"SSHplex: Failed to create window for '{hostname}'")
+                return False
+
+            # Get the main pane of the new window
+            pane = window.panes[0] if window.panes else None
+            if not pane:
+                self.logger.error(f"SSHplex: No pane found in new window for '{hostname}'")
+                return False
+
+            # Store the pane reference
+            self.panes[hostname] = pane
+
+            # Execute the provided command (should be SSH command)
+            if command:
+                pane.send_keys(command, enter=True)
+
+            self.logger.info(f"SSHplex: Window created for '{hostname}' successfully")
+            return True
+
+        except Exception as e:
+            self.logger.error(f"SSHplex: Failed to create window for '{hostname}': {e}")
+            return False
+
+    def set_pane_title(self, hostname: str, title: str) -> bool:
+        """Set the title of a specific pane."""
+        try:
+            if hostname not in self.panes:
+                self.logger.error(f"SSHplex: Pane for '{hostname}' not found")
+                return False
+
+            pane = self.panes[hostname]
+            # Set pane title using printf escape sequence
+            pane.send_keys(f'printf "\\033]2;{title}\\033\\\\"', enter=True)
+            return True
+
+        except Exception as e:
+            self.logger.error(f"SSHplex: Failed to set pane title for '{hostname}': {e}")
+            return False
+
+    def send_command(self, hostname: str, command: str) -> bool:
+        """Send a command to a specific pane."""
+        try:
+            if hostname not in self.panes:
+                self.logger.error(f"SSHplex: Pane for '{hostname}' not found")
+                return False
+
+            pane = self.panes[hostname]
+            pane.send_keys(command, enter=True)
+            self.logger.debug(f"SSHplex: Command sent to '{hostname}': {command}")
+            return True
+
+        except Exception as e:
+            self.logger.error(f"SSHplex: Failed to send command to '{hostname}': {e}")
+            return False
+
+    def broadcast_command(self, command: str) -> bool:
+        """Send a command to all panes."""
+        try:
+            success_count = 0
+            for hostname in self.panes:
+                if self.send_command(hostname, command):
+                    success_count += 1
+
+            self.logger.info(f"SSHplex: Broadcast command sent to {success_count}/{len(self.panes)} panes")
+            return success_count == len(self.panes)
+
+        except Exception as e:
+            self.logger.error(f"SSHplex: Failed to broadcast command: {e}")
+            return False
+
+    def close_session(self) -> None:
+        """Close the tmux session."""
+        try:
+            if self.session:
+                self.logger.info(f"SSHplex: Closing tmux session '{self.session_name}'")
+                self.session.kill_session()
+                self.session = None
+                self.window = None
+                self.panes.clear()
+
+        except Exception as e:
+            self.logger.error(f"SSHplex: Error closing session: {e}")
+
+    def attach_to_session(self, auto_attach: bool = True) -> None:
+        """Attach to the tmux session."""
+        try:
+            if self.session:
+                if auto_attach:
+                    self.logger.info(f"SSHplex: Auto-attaching to tmux session '{self.session_name}'")
+                    # Auto-attach to the session by replacing current shell
+                    import os
+                    import sys
+                    # Use exec to replace the current Python process with tmux attach
+                    os.execlp("tmux", "tmux", "attach-session", "-t", self.session_name)
+                else:
+                    self.logger.info(f"SSHplex: Tmux session '{self.session_name}' is ready for attachment")
+                    print(f"\nTo attach to the session, run: tmux attach-session -t {self.session_name}")
+            else:
+                self.logger.error("SSHplex: No session to attach to")
+
+        except Exception as e:
+            self.logger.error(f"SSHplex: Error attaching to session: {e}")
+
+    def get_session_name(self) -> str:
+        """Get the tmux session name for external attachment."""
+        return self.session_name
+
+    def setup_tiled_layout(self) -> bool:
+        """Set up tiled layout for multiple panes."""
+        try:
+            if self.window and len(self.panes) > 1:
+                self.window.select_layout('tiled')
+                self.logger.info("SSHplex: Applied tiled layout to tmux window")
+                return True
+            return False
+
+        except Exception as e:
+            self.logger.error(f"SSHplex: Failed to set tiled layout: {e}")
+            return False

sshplex/lib/sot/__init__.py

@@ -0,0 +1 @@
+# The logs directory is intentionally left blank.