sshplex 1.6.4__tar.gz → 1.7.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sshplex
-Version: 1.6.4
+Version: 1.7.0
 Summary: Multiplex your SSH connections with style
 Author-email: MJAHED Sabri <contact@sabrimjahed.com>
 License: MIT
@@ -110,9 +110,12 @@ sshplex
 | **NetBox** | `netbox` | None (included in base install) | Inventory-driven infrastructure with metadata |
 | **Ansible** | `ansible` | None | Reusing existing Ansible inventory files |
 | **Consul** | `consul` | `pip install "sshplex[consul]"` | Service discovery and dynamic node catalogs |
+| **Git** | `git` | `git` binary in PATH | Git-backed inventories with auto-pull (`static` or `ansible` YAML) |
 
 Provider activation is controlled by `sot.providers`, and each source is configured as an item in `sot.import`.
 
+Use multiple `git` imports and tune `priority` for deterministic overrides.
+
 
 ## Local Demo (Consul + Ansible)
 

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

@@ -57,9 +57,12 @@ sshplex
 | **NetBox** | `netbox` | None (included in base install) | Inventory-driven infrastructure with metadata |
 | **Ansible** | `ansible` | None | Reusing existing Ansible inventory files |
 | **Consul** | `consul` | `pip install "sshplex[consul]"` | Service discovery and dynamic node catalogs |
+| **Git** | `git` | `git` binary in PATH | Git-backed inventories with auto-pull (`static` or `ansible` YAML) |
 
 Provider activation is controlled by `sot.providers`, and each source is configured as an item in `sot.import`.
 
+Use multiple `git` imports and tune `priority` for deterministic overrides.
+
 
 ## Local Demo (Consul + Ansible)
 

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sshplex"
-version = "1.6.4"
+version = "1.7.0"
 description = "Multiplex your SSH connections with style"
 authors = [{name = "MJAHED Sabri", email = "contact@sabrimjahed.com"}]
 readme = "README.md"

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

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

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

@@ -127,6 +127,8 @@ def list_providers(config: Any, logger: Any) -> int:
             status_icon = "📝"
         elif provider.type == "consul":
             status_icon = "🔍"
+        elif provider.type == "git":
+            status_icon = "🔄"
         
         print(f"{i}. {status_icon} {provider.name}")
         print(f"   Type: {provider.type}")
@@ -137,6 +139,12 @@ def list_providers(config: Any, logger: Any) -> int:
             print(f"   Paths: {', '.join(provider.inventory_paths)}")
         elif provider.type == "consul" and provider.config:
             print(f"   Host: {provider.config.host}:{provider.config.port}")
+        elif provider.type == "git" and provider.repo_url:
+            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}"
+            print(f"   Source: {source_pattern}")
         elif provider.type == "static" and provider.hosts:
             print(f"   Hosts: {len(provider.hosts)} defined")
         

{sshplex-1.6.4 → sshplex-1.7.0}/sshplex/config-template.yaml

@@ -4,7 +4,7 @@ sshplex:
 
 # Source of Truth configuration
 sot:
-  providers: ["static", "netbox", "ansible", "consul"]  # Available: static, netbox, ansible, consul
+  providers: ["static", "netbox", "ansible", "consul", "git"]  # Available: static, netbox, ansible, consul, git
   import:
     - name: "production-servers"
       type: static
@@ -71,6 +71,28 @@ sot:
         verify: false
         dc: "lisbon"
         cert: ""  # Path to SSL certificate (optional)
+    - name: "personal-git-hosts"
+      type: git
+      repo_url: "git@github.com:your-user/sshplex-hosts.git"
+      branch: "main"
+      source_pattern: "hosts/**/*.y*ml"
+      inventory_format: "static" # static, ansible
+      auto_pull: true
+      pull_interval_seconds: 300
+      priority: 100
+      pull_strategy: "ff-only"
+    - name: "git-ansible-inventory"
+      type: git
+      repo_url: "git@github.com:your-org/ansible-inventory.git"
+      branch: "main"
+      source_pattern: "inventory/**/*.y*ml"
+      inventory_format: "ansible"
+      default_filters:
+        groups: ["webservers", "databases"]
+      auto_pull: true
+      pull_interval_seconds: 300
+      priority: 50
+      pull_strategy: "ff-only"
 
 ssh:
   username: "admin"

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

@@ -164,7 +164,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")
+    type: str = Field(..., description="Provider type: static, netbox, ansible, consul, git")
 
     # Static provider fields
     hosts: Optional[List[Dict[str, Any]]] = None
@@ -182,9 +182,24 @@ class SoTImportConfig(BaseModel):
     # Consul provider fields
     config: Optional[ConsulConfig] = None
 
+    # 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"
+    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"
+
 class SoTConfig(BaseModel):
     """Source of Truth configuration."""
-    providers: List[str] = Field(default_factory=lambda: ["static"], description="List of SoT providers to use: static, netbox, ansible")
+    providers: List[str] = Field(
+        default_factory=lambda: ["static"],
+        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")
 
 

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

@@ -1,7 +1,9 @@
 """Interactive onboarding wizard for SSHplex."""
 
 import os
+import platform
 import shutil
+import subprocess
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
@@ -62,6 +64,12 @@ class OnboardingWizard:
         
         # Generate configuration
         config = self._generate_config()
+
+        # Review before saving
+        self._show_configuration_summary(config)
+        if not Confirm.ask("\nSave this configuration?", default=True):
+            self.console.print("\n[yellow]Onboarding cancelled. Configuration was not saved.[/yellow]")
+            return False
         
         # Save configuration
         if self._save_config(config):
@@ -79,7 +87,7 @@ class OnboardingWizard:
         welcome_text.append("Let's configure SSHplex for your environment.")
         welcome_text.append("\nThis wizard will help you:")
         welcome_text.append("\n  • Detect SSH keys and system dependencies")
-        welcome_text.append("\n  • Configure inventory sources (NetBox, Ansible, Consul, etc.)")
+        welcome_text.append("\n  • Configure inventory sources (Static, NetBox, Ansible, Consul, Git)")
         welcome_text.append("\n  • Test connections before saving")
         welcome_text.append("\n  • Generate a working configuration file")
         
@@ -90,6 +98,8 @@ class OnboardingWizard:
     def _detect_environment(self) -> None:
         """Detect system environment and dependencies."""
         self.console.print("\n🔍 [bold]Detecting Environment[/bold]\n")
+        platform_name = platform.system()
+        self.detected_info['platform'] = platform_name
         
         # Detect SSH keys
         ssh_dir = Path.home() / ".ssh"
@@ -106,11 +116,22 @@ class OnboardingWizard:
         tmux_path = shutil.which("tmux")
         self.detected_info['tmux_installed'] = tmux_path is not None
         self.detected_info['tmux_path'] = tmux_path
+
+        # Detect git
+        git_path = shutil.which("git")
+        self.detected_info['git_installed'] = git_path is not None
+        self.detected_info['git_path'] = git_path
+
+        # Detect iTerm2 app (macOS only)
+        iterm_app_exists = platform_name.lower() == "darwin" and Path("/Applications/iTerm.app").exists()
+        self.detected_info['iterm2_installed'] = iterm_app_exists
         
         # Display detected info
         table = Table(show_header=False, box=None)
         table.add_column("Item", style="cyan")
         table.add_column("Status")
+
+        table.add_row("Platform", f"✅ {platform_name}")
         
         # SSH keys
         if ssh_keys:
@@ -124,7 +145,20 @@ class OnboardingWizard:
         if tmux_path:
             table.add_row("tmux", f"✅ {tmux_path}")
         else:
-            table.add_row("tmux", "❌ Not found (required for SSHplex)")
+            table.add_row("tmux", "⚠️  Not found (required for tmux backend)")
+
+        # git
+        if git_path:
+            table.add_row("git", f"✅ {git_path}")
+        else:
+            table.add_row("git", "⚠️  Not found (required for git inventory source)")
+
+        # iTerm2
+        if platform_name.lower() == "darwin":
+            if iterm_app_exists:
+                table.add_row("iTerm2", "✅ /Applications/iTerm.app")
+            else:
+                table.add_row("iTerm2", "ℹ️  Not found (optional, only for native iTerm2 backend)")
         
         self.console.print(table)
     
@@ -154,6 +188,7 @@ class OnboardingWizard:
             ("netbox", "NetBox (infrastructure source of truth)"),
             ("ansible", "Ansible inventory file"),
             ("consul", "HashiCorp Consul (service discovery)"),
+            ("git", "Git repository inventory (static or ansible YAML)"),
         ]
         
         self.console.print("\n[bold]Select inventory source type:[/bold]")
@@ -172,6 +207,8 @@ class OnboardingWizard:
             return self._configure_ansible()
         elif provider_type == "consul":
             return self._configure_consul()
+        elif provider_type == "git":
+            return self._configure_git()
         
         return None
     
@@ -333,6 +370,110 @@ class OnboardingWizard:
                     return None
         
         return config
+
+    def _configure_git(self) -> Optional[Dict[str, Any]]:
+        """Configure read-only git inventory provider."""
+        self.console.print("\n[bold cyan]Git Inventory Configuration[/bold cyan]")
+
+        if not self.detected_info.get('git_installed'):
+            self.console.print("[yellow]⚠️  git was not detected on this machine.[/yellow]")
+            if not Confirm.ask("Continue configuring git provider anyway?", default=False):
+                return None
+
+        name = Prompt.ask("Provider name", default="git-hosts")
+        repo_url = Prompt.ask("Repository URL", default="git@github.com:org/hosts.git")
+        branch = Prompt.ask("Branch", default="main")
+        source_pattern = Prompt.ask(
+            "Source pattern (path + glob)",
+            default="hosts/**/*.y*ml",
+        )
+        inventory_format = Prompt.ask(
+            "Inventory format",
+            choices=["static", "ansible"],
+            default="static",
+        )
+
+        while True:
+            priority_input = Prompt.ask("Priority", default="100")
+            try:
+                priority = int(priority_input)
+                break
+            except ValueError:
+                self.console.print(f"[red]Invalid priority: {priority_input}[/red]")
+
+        auto_pull = Confirm.ask("Enable auto pull", default=True)
+        pull_interval_seconds = 300
+        if auto_pull:
+            while True:
+                interval_input = Prompt.ask("Auto pull interval (seconds)", default="300")
+                try:
+                    pull_interval_seconds = int(interval_input)
+                    if pull_interval_seconds >= 0:
+                        break
+                    self.console.print("[red]Interval must be >= 0[/red]")
+                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,
+            "pull_interval_seconds": pull_interval_seconds,
+            "pull_strategy": "ff-only",
+        }
+
+        if inventory_format == "ansible":
+            groups_str = Prompt.ask(
+                "Ansible groups filter (comma-separated, optional)",
+                default="",
+            )
+            if groups_str.strip():
+                groups = [group.strip() for group in groups_str.split(",") if group.strip()]
+                if groups:
+                    config["default_filters"] = {"groups": groups}
+
+        if Confirm.ask("\nTest repository access?", default=True):
+            if self._test_git_connection(config):
+                self.console.print("✅ Repository access successful!")
+            else:
+                self.console.print("❌ Could not read remote branch/source. Check URL/auth/branch.")
+                if not Confirm.ask("Keep this configuration anyway?", default=False):
+                    return None
+
+        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."""
@@ -393,11 +534,67 @@ class OnboardingWizard:
         except Exception as e:
             self.logger.error(f"Consul connection failed: {e}")
             return False
+
+    def _test_git_connection(self, config: Dict[str, Any]) -> bool:
+        """Test git repository access and branch visibility."""
+        repo_url = str(config.get("repo_url", "")).strip()
+        branch = str(config.get("branch", "main")).strip() or "main"
+        self.logger.info(f"Testing git source access: {repo_url}@{branch}")
+        self.console.print("\n🔄 Testing repository access...")
+
+        if not repo_url:
+            self.logger.error("Git repository URL is empty")
+            return False
+
+        git_bin = shutil.which("git")
+        if not git_bin:
+            self.logger.error("git binary not found in PATH")
+            return False
+
+        try:
+            result = subprocess.run(
+                [git_bin, "ls-remote", "--heads", repo_url, branch],
+                capture_output=True,
+                text=True,
+                timeout=20,
+            )
+            if result.returncode != 0:
+                self.logger.error(f"git ls-remote failed: {result.stderr.strip()}")
+                return False
+
+            if not (result.stdout or "").strip():
+                self.logger.warning(
+                    f"Repository reachable but no matching branch found for '{branch}'"
+                )
+                return False
+
+            return True
+        except Exception as e:
+            self.logger.error(f"Git repository check failed: {e}")
+            return False
+
+    def _select_backend(self) -> str:
+        """Choose backend based on detected environment."""
+        platform_name = str(self.detected_info.get('platform', platform.system()))
+        tmux_installed = bool(self.detected_info.get('tmux_installed', False))
+        iterm2_installed = bool(self.detected_info.get('iterm2_installed', False))
+
+        if platform_name.lower() == "darwin" and iterm2_installed:
+            default_backend = "tmux" if tmux_installed else "iterm2-native"
+            backend = Prompt.ask(
+                "Backend",
+                choices=["tmux", "iterm2-native"],
+                default=default_backend,
+            )
+            return backend
+
+        return "tmux"
     
     def _generate_config(self) -> Dict[str, Any]:
         """Generate configuration dictionary."""
         # Use detected SSH key as default, fallback to common default if none found
         default_key = self.detected_info.get('default_ssh_key') or '~/.ssh/id_ed25519'
+        backend = self._select_backend()
         
         # Validate SSH port input
         while True:
@@ -431,6 +628,7 @@ class OnboardingWizard:
                 "file": "logs/sshplex.log"
             },
             "tmux": {
+                "backend": backend,
                 "control_with_iterm2": False
             },
             "ui": {
@@ -438,8 +636,60 @@ class OnboardingWizard:
                 "table_columns": ["name", "ip", "cluster", "role", "tags", "description", "provider"]
             }
         }
+
+        if backend == "tmux" and not self.detected_info.get('tmux_installed'):
+            self.console.print(
+                "\n[yellow]⚠️  tmux backend selected but tmux was not detected. "
+                "Install tmux or switch to iTerm2 native backend on macOS.[/yellow]"
+            )
         
         return config
+
+    def _show_configuration_summary(self, config: Dict[str, Any]) -> None:
+        """Display final config summary before save."""
+        self.console.print("\n🧾 [bold]Configuration Summary[/bold]\n")
+
+        ssh = config.get("ssh", {})
+        tmux = config.get("tmux", {})
+        imports = list((config.get("sot", {}) or {}).get("import", []) or [])
+
+        summary = Table(show_header=False, box=None)
+        summary.add_column("Item", style="cyan")
+        summary.add_column("Value")
+        summary.add_row("Config Path", str(self.config_path))
+        summary.add_row("Backend", str(tmux.get("backend", "tmux")))
+        summary.add_row("SSH Username", str(ssh.get("username", "")))
+        summary.add_row("SSH Port", str(ssh.get("port", 22)))
+        summary.add_row("SSH Key", str(ssh.get("key_path", "")))
+        summary.add_row("Sources", str(len(imports)))
+        self.console.print(summary)
+
+        if imports:
+            provider_table = Table(show_header=True, box=None)
+            provider_table.add_column("Name", style="bold")
+            provider_table.add_column("Type", style="magenta")
+            provider_table.add_column("Details", style="dim")
+
+            for provider in imports:
+                provider_name = str(provider.get("name", "unnamed"))
+                provider_type = str(provider.get("type", "unknown"))
+                details = ""
+                if provider_type == "static":
+                    details = f"hosts: {len(provider.get('hosts', []) or [])}"
+                elif provider_type == "ansible":
+                    details = f"paths: {len(provider.get('inventory_paths', []) or [])}"
+                elif provider_type == "netbox":
+                    details = str(provider.get("url", ""))
+                elif provider_type == "consul":
+                    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", "")))
+
+                provider_table.add_row(provider_name, provider_type, details)
+
+            self.console.print()
+            self.console.print(provider_table)
     
     def _save_config(self, config: Dict[str, Any]) -> bool:
         """Save configuration to file."""

{sshplex-1.6.4 → sshplex-1.7.0}/sshplex/lib/sot/factory.py

@@ -4,12 +4,14 @@ from __future__ import annotations
 
 import time
 from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
 from typing import Any
 
 from ..cache import HostCache
 from ..logger import get_logger
 from .ansible import AnsibleProvider
 from .base import Host, SoTProvider
+from .git import GitProvider
 from .netbox import NetBoxProvider
 from .static import StaticProvider
 
@@ -112,6 +114,8 @@ class SoTFactory:
                     provider = self._create_ansible_provider_from_import(import_config)
                 elif import_type == "consul":
                     provider = self._create_consul_provider(import_config)
+                elif import_type == "git":
+                    provider = self._create_git_provider(import_config)
                 else:
                     self.logger.error(f"Unknown SoT provider type: {import_type}")
                     continue
@@ -171,6 +175,18 @@ class SoTFactory:
             import_config=import_config
         )
 
+    def _create_git_provider(self, import_config: Any) -> GitProvider | None:
+        """Create Git provider instance from import configuration."""
+        repo_url = str(getattr(import_config, "repo_url", "") or "").strip()
+        if not repo_url:
+            self.logger.error(f"Git provider '{import_config.name}' missing required repo_url")
+            return None
+
+        cache_root = Path(getattr(self.config.cache, "cache_dir", "~/.cache/sshplex")).expanduser()
+        git_cache_dir = cache_root / "git"
+
+        return GitProvider(import_config=import_config, cache_dir=str(git_cache_dir))
+
     def _create_netbox_provider_from_import(self, import_config: Any) -> NetBoxProvider | None:
         """Create NetBox provider instance from import configuration.
 
@@ -551,3 +567,72 @@ class SoTFactory:
             True if cache is valid, False otherwise
         """
         return self.cache.is_cache_valid()
+
+    def sync_git_sources(self, force: bool = False) -> list[dict[str, Any]]:
+        """Sync configured git providers and return per-provider statuses."""
+        results: list[dict[str, Any]] = []
+        providers_to_sync = [provider for provider in self.providers if isinstance(provider, GitProvider)]
+
+        if not providers_to_sync:
+            providers_to_sync = self._initialize_git_providers_for_sync()
+
+        for provider in providers_to_sync:
+            if not isinstance(provider, GitProvider):
+                continue
+            try:
+                status = provider.sync(force=force)
+                results.append(status)
+            except Exception as e:
+                provider_name = getattr(provider, "provider_name", type(provider).__name__)
+                self.logger.error(f"Git sync failed for {provider_name}: {e}")
+                results.append(
+                    {
+                        "provider": provider_name,
+                        "status": "error",
+                        "message": str(e),
+                        "old_commit": None,
+                        "new_commit": None,
+                        "changed_files": 0,
+                    }
+                )
+        return results
+
+    def _initialize_git_providers_for_sync(self) -> list[GitProvider]:
+        """Initialize git providers directly from config for sync-only operations."""
+        initialized: list[GitProvider] = []
+        configured_imports = list(getattr(self.config.sot, "import_", []) or [])
+        if not configured_imports:
+            return initialized
+
+        enabled_provider_types = {
+            str(provider_type).strip()
+            for provider_type in (getattr(self.config.sot, "providers", []) or [])
+            if str(provider_type).strip()
+        }
+
+        providers_explicitly_set = True
+        if hasattr(self.config.sot, "model_fields_set"):
+            providers_explicitly_set = "providers" in getattr(self.config.sot, "model_fields_set", set())
+
+        if not providers_explicitly_set:
+            enabled_provider_types = {
+                str(getattr(import_config, "type", "")).strip()
+                for import_config in configured_imports
+                if str(getattr(import_config, "type", "")).strip()
+            }
+
+        for import_config in configured_imports:
+            import_type = str(getattr(import_config, "type", "")).strip()
+            if import_type != "git":
+                continue
+
+            if enabled_provider_types and import_type not in enabled_provider_types:
+                continue
+
+            provider = self._create_git_provider(import_config)
+            if provider is None:
+                continue
+            if provider.connect():
+                initialized.append(provider)
+
+        return initialized