sshplex 1.7.0__tar.gz → 1.8.0__tar.gz

{sshplex-1.7.0/sshplex.egg-info → sshplex-1.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sshplex
-Version: 1.7.0
+Version: 1.8.0
 Summary: Multiplex your SSH connections with style
 Author-email: MJAHED Sabri <contact@sabrimjahed.com>
 License: MIT
@@ -17,15 +17,14 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: POSIX :: Linux
 Classifier: Operating System :: MacOS
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: System :: Networking
 Classifier: Topic :: System :: Systems Administration
 Classifier: Topic :: Terminals
-Requires-Python: >=3.8
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pynetbox==7.6.1
@@ -90,7 +89,7 @@ sshplex
 
 ### Prerequisites
 
-- Python 3.8+
+- Python 3.10+
 - tmux (Linux/macOS) and/or iTerm2 (macOS)
 - SSH key configured for target hosts
 

{sshplex-1.7.0 → sshplex-1.8.0}/README.md

@@ -37,7 +37,7 @@ sshplex
 
 ### Prerequisites
 
-- Python 3.8+
+- Python 3.10+
 - tmux (Linux/macOS) and/or iTerm2 (macOS)
 - SSH key configured for target hosts
 

{sshplex-1.7.0 → sshplex-1.8.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sshplex"
-version = "1.7.0"
+version = "1.8.0"
 description = "Multiplex your SSH connections with style"
 authors = [{name = "MJAHED Sabri", email = "contact@sabrimjahed.com"}]
 readme = "README.md"
@@ -18,17 +18,16 @@ classifiers = [
     "Operating System :: POSIX :: Linux",
     "Operating System :: MacOS",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.8",
-    "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
     "Topic :: System :: Networking",
     "Topic :: System :: Systems Administration",
     "Topic :: Terminals",
 ]
 keywords = ["ssh", "tmux", "multiplexer", "netbox", "tui", "terminal"]
-requires-python = ">=3.8"
+requires-python = ">=3.10"
 dependencies = [
     "pynetbox==7.6.1",
     "textual==8.0.0",

{sshplex-1.7.0 → sshplex-1.8.0}/sshplex/__init__.py

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

{sshplex-1.7.0 → sshplex-1.8.0}/sshplex/cli.py

@@ -143,7 +143,7 @@ def list_providers(config: Any, logger: Any) -> int:
             branch = provider.branch or "main"
             inventory_format = provider.inventory_format or "static"
             print(f"   Repo: {provider.repo_url} [{branch}, {inventory_format}]")
-            source_pattern = provider.source_pattern or f"{provider.path}/{provider.file_glob}"
+            source_pattern = provider.source_pattern or "hosts/**/*.y*ml"
             print(f"   Source: {source_pattern}")
         elif provider.type == "static" and provider.hosts:
             print(f"   Hosts: {len(provider.hosts)} defined")

{sshplex-1.7.0 → sshplex-1.8.0}/sshplex/lib/cache.py

@@ -1,6 +1,8 @@
 """SSHplex host cache management for optimized startup performance."""
 
+import contextlib
 import os
+import tempfile
 import threading
 from datetime import datetime, timedelta
 from pathlib import Path
@@ -28,9 +30,9 @@ class HostCache:
         self.logger = get_logger()
 
         if cache_dir is None:
-            cache_dir = os.path.expanduser("~/.cache/sshplex")
+            cache_dir = "~/.cache/sshplex"
 
-        self.cache_dir = Path(cache_dir)
+        self.cache_dir = Path(cache_dir).expanduser()
         self.cache_ttl = timedelta(hours=cache_ttl_hours)
         self.cache_file = self.cache_dir / "hosts.yaml"
         self.metadata_file = self.cache_dir / "cache_metadata.yaml"
@@ -70,19 +72,37 @@ class HostCache:
                 with open(self.metadata_file) as f:
                     metadata = yaml.safe_load(f)
 
-                if not metadata or 'timestamp' not in metadata:
+                if not isinstance(metadata, dict) or 'timestamp' not in metadata:
                     return False
 
                 cache_time = datetime.fromisoformat(metadata['timestamp'])
                 return datetime.now() - cache_time < self.cache_ttl
 
-            except (yaml.YAMLError, ValueError, KeyError) as e:
+            except (yaml.YAMLError, ValueError, KeyError, OSError) as e:
                 self.logger.warning(f"Failed to validate cache: {e}")
                 return False
             except Exception as e:
                 self.logger.error(f"Unexpected error validating cache: {e}")
                 return False
 
+    def _atomic_write_yaml(self, file_path: Path, payload: Any) -> None:
+        """Write YAML payload atomically to avoid partial/corrupt cache writes."""
+        fd, temp_path_text = tempfile.mkstemp(
+            prefix=f".{file_path.name}.",
+            suffix=".tmp",
+            dir=str(self.cache_dir),
+            text=True,
+        )
+        temp_path = Path(temp_path_text)
+        try:
+            with os.fdopen(fd, "w") as handle:
+                yaml.safe_dump(payload, handle, default_flow_style=False, sort_keys=True)
+            os.replace(temp_path, file_path)
+        finally:
+            if temp_path.exists():
+                with contextlib.suppress(OSError):
+                    temp_path.unlink()
+
     def save_hosts(self, hosts: List[Host], provider_info: Dict[str, Any]) -> bool:
         """Save hosts to cache with metadata.
 
@@ -95,19 +115,10 @@ class HostCache:
         """
         with self._lock:
             try:
-                # Prepare hosts data for serialization
-                hosts_data = []
-                for host in hosts:
-                    host_dict = {
-                        'name': host.name,
-                        'ip': host.ip,
-                        'metadata': host.metadata
-                    }
-                    hosts_data.append(host_dict)
+                hosts_data = [host.to_dict() for host in hosts]
 
                 # Save hosts data
-                with open(self.cache_file, 'w') as f:
-                    yaml.dump(hosts_data, f, default_flow_style=False, sort_keys=True)
+                self._atomic_write_yaml(self.cache_file, hosts_data)
 
                 # Save metadata
                 cache_metadata = {
@@ -117,8 +128,7 @@ class HostCache:
                     'cache_version': '1.0'
                 }
 
-                with open(self.metadata_file, 'w') as f:
-                    yaml.dump(cache_metadata, f, default_flow_style=False, sort_keys=True)
+                self._atomic_write_yaml(self.metadata_file, cache_metadata)
 
                 self.logger.info(f"Successfully cached {len(hosts)} hosts to {self.cache_file}")
                 return True
@@ -155,12 +165,8 @@ class HostCache:
                     if 'name' not in host_dict or 'ip' not in host_dict:
                         self.logger.warning(f"Skipping host with missing required fields: {host_dict}")
                         continue
-                        
-                    host = Host(
-                        name=host_dict['name'],
-                        ip=host_dict['ip'],
-                        **host_dict.get('metadata', {})
-                    )
+
+                    host = Host.from_dict(host_dict)
                     hosts.append(host)
 
                 self.logger.info(f"Successfully loaded {len(hosts)} hosts from cache")

{sshplex-1.7.0 → sshplex-1.8.0}/sshplex/lib/config.py

@@ -5,10 +5,27 @@ from pathlib import Path
 from typing import Any, Dict, List, Optional
 
 import yaml
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, field_validator
 
 from .. import __version__
 
+SUPPORTED_SOT_PROVIDER_TYPES = ("static", "netbox", "ansible", "consul", "git")
+SOT_PROVIDER_LABELS = {
+    "static": "Static",
+    "netbox": "NetBox",
+    "ansible": "Ansible",
+    "consul": "Consul",
+    "git": "Git",
+}
+
+SUPPORTED_MUX_BACKENDS = ("tmux", "iterm2-native")
+MUX_BACKEND_LABELS = {
+    "tmux": "tmux",
+    "iterm2-native": "iTerm2 Native",
+}
+
+SUPPORTED_GIT_INVENTORY_FORMATS = ("static", "ansible")
+
 
 class SSHplexConfig(BaseModel):
     """SSHplex main configuration."""
@@ -16,15 +33,6 @@ class SSHplexConfig(BaseModel):
     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)
-
-
 class LoggingConfig(BaseModel):
     """Logging configuration."""
     enabled: bool = True
@@ -42,7 +50,7 @@ class UIConfig(BaseModel):
 class Proxy(BaseModel):
     """ImportProxies configuration with defaults."""
     name: str = Field("", description="Proxy name")
-    imports: list = Field([], description="List of imports that will use this proxy")
+    imports: list = Field(default_factory=list, description="List of imports that will use this proxy")
     host: str = Field("", description="Proxy host or ip")
     username: str = Field("", description="Proxy username")
     key_path: str = Field("", description="Proxy key")
@@ -109,6 +117,16 @@ class TmuxConfig(BaseModel):
         description="Split pattern for iTerm2 native: alternate, vertical, horizontal"
     )
 
+    @field_validator("backend")
+    @classmethod
+    def validate_backend_value(cls, value: str) -> str:
+        normalized = str(value or "").strip().lower()
+        if normalized not in SUPPORTED_MUX_BACKENDS:
+            raise ValueError(
+                f"Invalid backend: {value}. Must be one of: {list(SUPPORTED_MUX_BACKENDS)}"
+            )
+        return normalized
+
     def validate_backend_config(self) -> bool:
         """Validate backend configuration.
 
@@ -118,10 +136,9 @@ class TmuxConfig(BaseModel):
         import platform
 
         # Validate backend option
-        valid_backends = ["tmux", "iterm2-native"]
-        if self.backend not in valid_backends:
+        if self.backend not in SUPPORTED_MUX_BACKENDS:
             raise ValueError(
-                f"Invalid backend: {self.backend}. Must be one of: {valid_backends}"
+                f"Invalid backend: {self.backend}. Must be one of: {list(SUPPORTED_MUX_BACKENDS)}"
             )
 
         # Validate iTerm2 native mode on macOS only
@@ -146,11 +163,6 @@ class TmuxConfig(BaseModel):
         return True
 
 
-class AnsibleConfig(BaseModel):
-    """Ansible inventory configuration."""
-    inventory_paths: List[str] = Field(default_factory=list, description="List of paths to Ansible inventory YAML files")
-    default_filters: Dict[str, Any] = Field(default_factory=dict)
-
 class ConsulConfig(BaseModel):
     """Consul-specific configuration with defaults."""
     host: str = Field("consul.example.com", description="Consul host address")
@@ -164,7 +176,7 @@ class ConsulConfig(BaseModel):
 class SoTImportConfig(BaseModel):
     """Individual SoT import configuration."""
     name: str = Field(..., description="Unique name for this import")
-    type: str = Field(..., description="Provider type: static, netbox, ansible, consul, git")
+    type: str = Field(..., description=f"Provider type: {', '.join(SUPPORTED_SOT_PROVIDER_TYPES)}")
 
     # Static provider fields
     hosts: Optional[List[Dict[str, Any]]] = None
@@ -185,23 +197,72 @@ class SoTImportConfig(BaseModel):
     # Git provider fields
     repo_url: Optional[str] = None
     branch: Optional[str] = "main"
-    source_pattern: Optional[str] = None
-    path: Optional[str] = "hosts"
-    file_glob: Optional[str] = "**/*.y*ml"
+    source_pattern: Optional[str] = "hosts/**/*.y*ml"
     auto_pull: Optional[bool] = True
     pull_interval_seconds: Optional[int] = 300
     priority: Optional[int] = 100
     pull_strategy: Optional[str] = "ff-only"
     inventory_format: Optional[str] = "static"
 
+    @field_validator("type")
+    @classmethod
+    def validate_provider_type(cls, value: str) -> str:
+        normalized = str(value or "").strip().lower()
+        if normalized not in SUPPORTED_SOT_PROVIDER_TYPES:
+            raise ValueError(
+                f"Unsupported provider type '{value}'. "
+                f"Supported values: {list(SUPPORTED_SOT_PROVIDER_TYPES)}"
+            )
+        return normalized
+
+    @field_validator("pull_strategy")
+    @classmethod
+    def validate_pull_strategy(cls, value: Optional[str]) -> Optional[str]:
+        if value is None:
+            return value
+        normalized = str(value).strip().lower()
+        if normalized and normalized != "ff-only":
+            raise ValueError("git pull_strategy only supports 'ff-only'")
+        return normalized or "ff-only"
+
+    @field_validator("inventory_format")
+    @classmethod
+    def validate_inventory_format(cls, value: Optional[str]) -> Optional[str]:
+        if value is None:
+            return value
+        normalized = str(value).strip().lower()
+        if normalized not in SUPPORTED_GIT_INVENTORY_FORMATS:
+            raise ValueError(
+                f"Unsupported git inventory format '{value}'. "
+                f"Supported values: {list(SUPPORTED_GIT_INVENTORY_FORMATS)}"
+            )
+        return normalized
+
 class SoTConfig(BaseModel):
     """Source of Truth configuration."""
     providers: List[str] = Field(
-        default_factory=lambda: ["static"],
+        default_factory=list,
         description="List of SoT providers to use: static, netbox, ansible, consul, git",
     )
     import_: List[SoTImportConfig] = Field(alias='import', default_factory=list, description="List of import configurations")
 
+    @field_validator("providers")
+    @classmethod
+    def validate_enabled_providers(cls, value: List[str]) -> List[str]:
+        normalized: List[str] = []
+        for provider in value or []:
+            provider_name = str(provider or "").strip().lower()
+            if not provider_name:
+                continue
+            if provider_name not in SUPPORTED_SOT_PROVIDER_TYPES:
+                raise ValueError(
+                    f"Unsupported provider '{provider_name}'. "
+                    f"Supported values: {list(SUPPORTED_SOT_PROVIDER_TYPES)}"
+                )
+            if provider_name not in normalized:
+                normalized.append(provider_name)
+        return normalized
+
 
 class CacheConfig(BaseModel):
     """Host cache configuration."""
@@ -214,8 +275,6 @@ class Config(BaseModel):
     """Main SSHplex configuration model."""
     sshplex: SSHplexConfig = Field(default_factory=SSHplexConfig)
     sot: SoTConfig = Field(default_factory=SoTConfig)
-    netbox: Optional[NetBoxConfig] = None
-    ansible_inventory: Optional[AnsibleConfig] = None
     ssh: SSHConfig = Field(default_factory=SSHConfig)
     tmux: TmuxConfig = Field(default_factory=TmuxConfig)
     logging: LoggingConfig = Field(default_factory=LoggingConfig)

{sshplex-1.7.0 → sshplex-1.8.0}/sshplex/lib/onboarding/wizard.py

@@ -14,7 +14,11 @@ from rich.prompt import Confirm, Prompt
 from rich.table import Table
 from rich.text import Text
 
-from ..config import Config
+from ..config import (
+    SUPPORTED_MUX_BACKENDS,
+    SUPPORTED_SOT_PROVIDER_TYPES,
+    Config,
+)
 from ..logger import get_logger
 
 
@@ -181,14 +185,18 @@ class OnboardingWizard:
             Provider configuration dict or None if cancelled
         """
         self.console.print("\n" + "─" * 60)
-        
+
         # Provider type selection
+        provider_descriptions = {
+            "static": "Static host list (manual entry)",
+            "netbox": "NetBox (infrastructure source of truth)",
+            "ansible": "Ansible inventory file",
+            "consul": "HashiCorp Consul (service discovery)",
+            "git": "Git repository inventory (static or ansible YAML)",
+        }
         provider_types = [
-            ("static", "Static host list (manual entry)"),
-            ("netbox", "NetBox (infrastructure source of truth)"),
-            ("ansible", "Ansible inventory file"),
-            ("consul", "HashiCorp Consul (service discovery)"),
-            ("git", "Git repository inventory (static or ansible YAML)"),
+            (provider_type, provider_descriptions.get(provider_type, provider_type))
+            for provider_type in SUPPORTED_SOT_PROVIDER_TYPES
         ]
         
         self.console.print("\n[bold]Select inventory source type:[/bold]")
@@ -197,20 +205,19 @@ class OnboardingWizard:
         
         choice = Prompt.ask("\nChoice", choices=[str(i) for i in range(1, len(provider_types) + 1)], default="1")
         provider_type = provider_types[int(choice) - 1][0]
-        
-        # Configure based on type
-        if provider_type == "static":
-            return self._configure_static()
-        elif provider_type == "netbox":
-            return self._configure_netbox()
-        elif provider_type == "ansible":
-            return self._configure_ansible()
-        elif provider_type == "consul":
-            return self._configure_consul()
-        elif provider_type == "git":
-            return self._configure_git()
-        
-        return None
+
+        configurators = {
+            "static": self._configure_static,
+            "netbox": self._configure_netbox,
+            "ansible": self._configure_ansible,
+            "consul": self._configure_consul,
+            "git": self._configure_git,
+        }
+        handler = configurators.get(provider_type)
+        if handler is None:
+            self.console.print(f"[red]Unsupported provider type: {provider_type}[/red]")
+            return None
+        return handler()
     
     def _configure_static(self) -> Optional[Dict[str, Any]]:
         """Configure static host provider."""
@@ -414,16 +421,12 @@ class OnboardingWizard:
                 except ValueError:
                     self.console.print(f"[red]Invalid interval: {interval_input}[/red]")
 
-        path, file_glob = self._split_source_pattern_legacy(source_pattern)
-
         config: Dict[str, Any] = {
             "name": name,
             "type": "git",
             "repo_url": repo_url,
             "branch": branch,
             "source_pattern": source_pattern,
-            "path": path,
-            "file_glob": file_glob,
             "inventory_format": inventory_format,
             "priority": priority,
             "auto_pull": auto_pull,
@@ -451,30 +454,6 @@ class OnboardingWizard:
 
         return config
 
-    @staticmethod
-    def _split_source_pattern_legacy(source_pattern: str) -> tuple[str, str]:
-        """Split source pattern into path/glob compatibility fields."""
-        normalized = str(source_pattern or "").strip().lstrip("/")
-        if not normalized:
-            return "hosts", "**/*.y*ml"
-
-        if normalized.endswith((".yml", ".yaml")):
-            return normalized, "**/*.y*ml"
-
-        wildcard_chars = {"*", "?", "["}
-        parts = normalized.split("/")
-        wildcard_index = -1
-        for idx, part in enumerate(parts):
-            if any(char in part for char in wildcard_chars):
-                wildcard_index = idx
-                break
-
-        if wildcard_index == -1:
-            return normalized, "**/*.y*ml"
-        if wildcard_index == 0:
-            return ".", normalized
-        return "/".join(parts[:wildcard_index]), "/".join(parts[wildcard_index:])
-    
     def _test_netbox_connection(self, config: Dict[str, Any]) -> bool:
         """Test NetBox connection."""
         self.logger.info(f"Testing NetBox connection to {config['url']}")
@@ -583,7 +562,7 @@ class OnboardingWizard:
             default_backend = "tmux" if tmux_installed else "iterm2-native"
             backend = Prompt.ask(
                 "Backend",
-                choices=["tmux", "iterm2-native"],
+                choices=list(SUPPORTED_MUX_BACKENDS),
                 default=default_backend,
             )
             return backend
@@ -684,7 +663,7 @@ class OnboardingWizard:
                     cfg = provider.get("config", {}) or {}
                     details = f"{cfg.get('scheme', 'http')}://{cfg.get('host', 'localhost')}:{cfg.get('port', 8500)}"
                 elif provider_type == "git":
-                    details = str(provider.get("source_pattern", provider.get("path", "")))
+                    details = str(provider.get("source_pattern", ""))
 
                 provider_table.add_row(provider_name, provider_type, details)
 

sshplex-1.8.0/sshplex/lib/sot/base.py

@@ -0,0 +1,108 @@
+"""Base classes for Source of Truth providers."""
+
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List, Optional
+
+
+class Host:
+    """Simple host data structure."""
+
+    _RESERVED_METADATA_KEYS = {"name", "ip", "metadata"}
+
+    def __init__(
+        self,
+        name: str,
+        ip: str,
+        metadata: Optional[Dict[str, Any]] = None,
+        **kwargs: Any,
+    ) -> None:
+        self.name = name
+        self.ip = ip
+        self.metadata: Dict[str, Any] = {}
+
+        if metadata:
+            self.update_metadata(metadata)
+        if kwargs:
+            self.update_metadata(kwargs)
+
+    def update_metadata(self, values: Dict[str, Any]) -> None:
+        """Merge metadata values and mirror them as instance attributes."""
+        for raw_key, value in values.items():
+            key = str(raw_key)
+            if key in self._RESERVED_METADATA_KEYS:
+                continue
+            self.metadata[key] = value
+            setattr(self, key, value)
+
+    def merge_metadata(self, values: Dict[str, Any]) -> None:
+        """Compatibility helper to merge metadata values in-place."""
+        self.update_metadata(values)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Serialize host object to cache-friendly dictionary."""
+        return {
+            "name": self.name,
+            "ip": self.ip,
+            "metadata": dict(self.metadata),
+        }
+
+    @classmethod
+    def from_dict(cls, payload: Dict[str, Any]) -> "Host":
+        """Create host object from serialized dictionary payload."""
+        metadata = payload.get("metadata", {})
+        if not isinstance(metadata, dict):
+            metadata = {}
+
+        extras = {
+            key: value
+            for key, value in payload.items()
+            if key not in cls._RESERVED_METADATA_KEYS
+        }
+        merged_metadata = dict(metadata)
+        merged_metadata.update(extras)
+
+        return cls(
+            name=str(payload["name"]),
+            ip=str(payload["ip"]),
+            metadata=merged_metadata,
+        )
+
+    def __str__(self) -> str:
+        return f"{self.name} ({self.ip})"
+
+    def __repr__(self) -> str:
+        return f"Host(name='{self.name}', ip='{self.ip}')"
+
+
+class SoTProvider(ABC):
+    """Abstract base class for Source of Truth providers."""
+
+    @abstractmethod
+    def connect(self) -> bool:
+        """Establish connection to the SoT provider.
+
+        Returns:
+            True if connection successful, False otherwise
+        """
+        pass
+
+    @abstractmethod
+    def get_hosts(self, filters: Optional[Dict[str, Any]] = None) -> List[Host]:
+        """Retrieve hosts from the SoT provider.
+
+        Args:
+            filters: Optional filters to apply
+
+        Returns:
+            List of Host objects
+        """
+        pass
+
+    @abstractmethod
+    def test_connection(self) -> bool:
+        """Test connection to the SoT provider.
+
+        Returns:
+            True if connection is healthy, False otherwise
+        """
+        pass