souleyez 2.43.26__py3-none-any.whl → 2.43.34__py3-none-any.whl

souleyez/ui/tool_setup.py

@@ -29,48 +29,53 @@ def _reset_terminal():
     """Reset terminal to sane state after interrupt."""
     try:
         # Reset terminal using stty
-        subprocess.run(['stty', 'sane'], check=False, timeout=5)
+        subprocess.run(["stty", "sane"], check=False, timeout=5)
         # Also try the reset command for good measure
-        subprocess.run(['reset', '-I'], check=False, timeout=5,
-                       stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        subprocess.run(
+            ["reset", "-I"],
+            check=False,
+            timeout=5,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
     except Exception:
         pass
 
 
 # Prerequisites needed for various install methods
 PREREQUISITES = {
-    'build-deps': {
-        'check': None,  # Always install to ensure all deps present
-        'install': 'sudo apt install -y build-essential python3-dev libxml2-dev libxslt1-dev libuv1-dev libffi-dev libssl-dev rustc cargo',
-        'description': 'Build dependencies for Python packages with native extensions',
-        'always_install': True  # Flag to always run this
+    "build-deps": {
+        "check": None,  # Always install to ensure all deps present
+        "install": "sudo apt install -y build-essential python3-dev libxml2-dev libxslt1-dev libuv1-dev libffi-dev libssl-dev rustc cargo",
+        "description": "Build dependencies for Python packages with native extensions",
+        "always_install": True,  # Flag to always run this
     },
-    'pipx': {
-        'check': 'pipx',
-        'install': 'sudo apt install -y pipx && pipx ensurepath',
-        'description': 'Python application installer (for theHarvester, NetExec, etc.)',
-        'path_additions': ['~/.local/bin']
+    "pipx": {
+        "check": "pipx",
+        "install": "sudo apt install -y pipx && pipx ensurepath",
+        "description": "Python application installer (for theHarvester, NetExec, etc.)",
+        "path_additions": ["~/.local/bin"],
     },
-    'golang': {
-        'check': 'go',
-        'install': 'sudo apt install -y golang-go',
-        'description': 'Go programming language (for nuclei, ffuf)',
-        'path_additions': ['~/go/bin']
+    "golang": {
+        "check": "go",
+        "install": "sudo apt install -y golang-go",
+        "description": "Go programming language (for nuclei, ffuf)",
+        "path_additions": ["~/go/bin"],
     },
-    'ruby': {
-        'check': 'gem',
-        'install': 'sudo apt install -y ruby-full ruby-dev build-essential',
-        'description': 'Ruby programming language (for wpscan)'
+    "ruby": {
+        "check": "gem",
+        "install": "sudo apt install -y ruby-full ruby-dev build-essential",
+        "description": "Ruby programming language (for wpscan)",
     },
-    'snap': {
-        'check': 'snap',
-        'install': 'sudo apt install -y snapd',
-        'description': 'Snap package manager (for enum4linux)'
+    "snap": {
+        "check": "snap",
+        "install": "sudo apt install -y snapd",
+        "description": "Snap package manager (for enum4linux)",
     },
-    'git': {
-        'check': 'git',
-        'install': 'sudo apt install -y git',
-        'description': 'Git version control (for exploitdb, Responder)'
+    "git": {
+        "check": "git",
+        "install": "sudo apt install -y git",
+        "description": "Git version control (for exploitdb, Responder)",
     },
 }
 
@@ -129,12 +134,15 @@ def _add_paths_to_shell_rc():
             pass  # Don't fail on PATH configuration issues
 
 
-def _run_command(cmd: str, console, description: str = "", capture: bool = False) -> tuple:
+def _run_command(
+    cmd: str, console, description: str = "", capture: bool = False
+) -> tuple:
     """Run a command with proper error handling."""
     import sys
+
     try:
         # Never capture sudo commands - password prompt needs to be visible
-        if cmd.strip().startswith('sudo'):
+        if cmd.strip().startswith("sudo"):
             capture = False
             # Flush output and print newline so sudo prompt appears on new line
             sys.stdout.flush()
@@ -147,7 +155,7 @@ def _run_command(cmd: str, console, description: str = "", capture: bool = False
                 shell=True,
                 capture_output=True,
                 text=True,
-                timeout=600  # 10 minute timeout
+                timeout=600,  # 10 minute timeout
             )
             return result.returncode == 0, result.stdout, result.stderr
         else:
@@ -155,7 +163,7 @@ def _run_command(cmd: str, console, description: str = "", capture: bool = False
                 cmd,
                 shell=True,
                 stdin=sys.stdin,  # Ensure stdin is connected for password input
-                timeout=600
+                timeout=600,
             )
             return result.returncode == 0, "", ""
     except subprocess.TimeoutExpired:
@@ -166,19 +174,19 @@ def _run_command(cmd: str, console, description: str = "", capture: bool = False
 
 # Tools that need privileged access
 # Binary tools: simple executables that need sudo
-PRIVILEGED_BINARY_TOOLS = ['nmap']
+PRIVILEGED_BINARY_TOOLS = ["nmap"]
 
 # Script-based tools: need sudo to run interpreter + script
 # Format: {'name': {'interpreter': path, 'script_paths': [possible locations], 'description': str}}
 PRIVILEGED_SCRIPT_TOOLS = {
-    'responder': {
-        'interpreter': '/usr/bin/python3',
-        'script_paths': [
-            '/usr/share/responder/Responder.py',
-            '/opt/Responder/Responder.py',
-            str(Path.home() / 'tools/Responder/Responder.py'),
+    "responder": {
+        "interpreter": "/usr/bin/python3",
+        "script_paths": [
+            "/usr/share/responder/Responder.py",
+            "/opt/Responder/Responder.py",
+            str(Path.home() / "tools/Responder/Responder.py"),
         ],
-        'description': 'LLMNR/NBT-NS credential capture'
+        "description": "LLMNR/NBT-NS credential capture",
     }
 }
 
@@ -199,11 +207,9 @@ def _check_sudoers_configured_binary(tool_name: str) -> bool:
 
     # Try running sudo -n (non-interactive) to see if NOPASSWD is set
     try:
-        subprocess.run(['sudo', '-k'], capture_output=True, timeout=5)
+        subprocess.run(["sudo", "-k"], capture_output=True, timeout=5)
         result = subprocess.run(
-            ['sudo', '-n', tool_path, '--version'],
-            capture_output=True,
-            timeout=5
+            ["sudo", "-n", tool_path, "--version"], capture_output=True, timeout=5
         )
         return result.returncode == 0
     except Exception:
@@ -217,11 +223,11 @@ def _check_sudoers_configured_script(interpreter: str, script_path: str) -> bool
 
     # Try running sudo -n with interpreter + script
     try:
-        subprocess.run(['sudo', '-k'], capture_output=True, timeout=5)
+        subprocess.run(["sudo", "-k"], capture_output=True, timeout=5)
         result = subprocess.run(
-            ['sudo', '-n', interpreter, script_path, '--help'],
+            ["sudo", "-n", interpreter, script_path, "--help"],
             capture_output=True,
-            timeout=5
+            timeout=5,
         )
         return result.returncode == 0
     except Exception:
@@ -243,11 +249,13 @@ def _configure_sudoers(console):
 
     # Check script-based tools
     for tool_name, tool_info in PRIVILEGED_SCRIPT_TOOLS.items():
-        script_path = _find_script_path(tool_info['script_paths'])
+        script_path = _find_script_path(tool_info["script_paths"])
         if script_path:
-            interpreter = tool_info['interpreter']
+            interpreter = tool_info["interpreter"]
             if not _check_sudoers_configured_script(interpreter, script_path):
-                script_tools_to_configure.append((tool_name, interpreter, script_path, tool_info['description']))
+                script_tools_to_configure.append(
+                    (tool_name, interpreter, script_path, tool_info["description"])
+                )
 
     if not binary_tools_to_configure and not script_tools_to_configure:
         return  # All configured or not installed
@@ -256,7 +264,9 @@ def _configure_sudoers(console):
     console.print("  " + "═" * 60)
     console.print("[bold cyan]  PRIVILEGED SCAN SETUP[/bold cyan]")
     console.print()
-    console.print("  Some scans require root privileges (SYN scans, credential capture).")
+    console.print(
+        "  Some scans require root privileges (SYN scans, credential capture)."
+    )
     console.print("  SoulEyez can configure passwordless sudo so these scans")
     console.print("  work automatically without running as root.")
     console.print()
@@ -267,9 +277,13 @@ def _configure_sudoers(console):
         console.print(f"    • {tool_name} ({description})")
     console.print()
 
-    if not click.confirm("  Configure passwordless sudo for these tools?", default=True):
+    if not click.confirm(
+        "  Configure passwordless sudo for these tools?", default=True
+    ):
         console.print()
-        console.print("  [yellow]Skipped.[/yellow] Privileged scans will require running as root.")
+        console.print(
+            "  [yellow]Skipped.[/yellow] Privileged scans will require running as root."
+        )
         console.print("  Run 'souleyez setup --fix-permissions' later to configure.")
         return
 
@@ -287,7 +301,9 @@ def _configure_sudoers(console):
             proc = subprocess.run(cmd, shell=True, timeout=60)  # nosec B602
 
             if proc.returncode == 0:
-                console.print(f"    [green]✓[/green] {tool_name} - configured for privileged scans")
+                console.print(
+                    f"    [green]✓[/green] {tool_name} - configured for privileged scans"
+                )
             else:
                 console.print(f"    [red]✗[/red] {tool_name} - failed to configure")
         except subprocess.TimeoutExpired:
@@ -306,7 +322,9 @@ def _configure_sudoers(console):
             proc = subprocess.run(cmd, shell=True, timeout=60)  # nosec B602
 
             if proc.returncode == 0:
-                console.print(f"    [green]✓[/green] {tool_name} - configured for privileged scans")
+                console.print(
+                    f"    [green]✓[/green] {tool_name} - configured for privileged scans"
+                )
             else:
                 console.print(f"    [red]✗[/red] {tool_name} - failed to configure")
         except subprocess.TimeoutExpired:
@@ -322,15 +340,15 @@ def _ensure_msfdb_initialized(console):
     from pathlib import Path
 
     # Check if msfdb exists (either apt install or official installer)
-    msfdb_path = shutil.which('msfdb')
+    msfdb_path = shutil.which("msfdb")
     if not msfdb_path:
         # Try the official installer path
-        msfdb_path = '/opt/metasploit-framework/bin/msfdb'
+        msfdb_path = "/opt/metasploit-framework/bin/msfdb"
         if not Path(msfdb_path).exists():
             return  # Metasploit not installed
 
     # Check if database is already initialized by looking for database.yml
-    user_db_yml = Path.home() / '.msf4' / 'database.yml'
+    user_db_yml = Path.home() / ".msf4" / "database.yml"
     if user_db_yml.exists():
         return  # Already initialized
 
@@ -344,7 +362,9 @@ def _ensure_msfdb_initialized(console):
 
     if not click.confirm("  Initialize MSF database now?", default=True):
         console.print()
-        console.print("  [yellow]Skipped.[/yellow] Run 'sudo msfdb init' manually when needed.")
+        console.print(
+            "  [yellow]Skipped.[/yellow] Run 'sudo msfdb init' manually when needed."
+        )
         return
 
     console.print()
@@ -353,30 +373,36 @@ def _ensure_msfdb_initialized(console):
     try:
         # Use sudo for msfdb init (required on Kali and some other distros)
         result = subprocess.run(
-            ['sudo', msfdb_path, 'init'],
+            ["sudo", msfdb_path, "init"],
             capture_output=True,
-            timeout=300  # 5 minute timeout
+            timeout=300,  # 5 minute timeout
         )
 
         if result.returncode == 0:
             console.print("  [green]✓ MSF database initialized[/green]")
 
             # Copy database.yml to /root/.msf4/ so sudo msfconsole can connect
-            user_db_yml = Path.home() / '.msf4' / 'database.yml'
+            user_db_yml = Path.home() / ".msf4" / "database.yml"
             if user_db_yml.exists():
                 console.print("  [dim]Configuring sudo access to MSF database...[/dim]")
                 try:
-                    subprocess.run(['sudo', 'mkdir', '-p', '/root/.msf4'], capture_output=True)
+                    subprocess.run(
+                        ["sudo", "mkdir", "-p", "/root/.msf4"], capture_output=True
+                    )
                     copy_result = subprocess.run(
-                        ['sudo', 'cp', str(user_db_yml), '/root/.msf4/database.yml'],
-                        capture_output=True
+                        ["sudo", "cp", str(user_db_yml), "/root/.msf4/database.yml"],
+                        capture_output=True,
                     )
                     if copy_result.returncode == 0:
                         console.print("  [green]✓ Sudo MSF access configured[/green]")
                     else:
-                        console.print("  [yellow]⚠ Run: sudo cp ~/.msf4/database.yml /root/.msf4/[/yellow]")
+                        console.print(
+                            "  [yellow]⚠ Run: sudo cp ~/.msf4/database.yml /root/.msf4/[/yellow]"
+                        )
                 except Exception:
-                    console.print("  [yellow]⚠ Run: sudo cp ~/.msf4/database.yml /root/.msf4/[/yellow]")
+                    console.print(
+                        "  [yellow]⚠ Run: sudo cp ~/.msf4/database.yml /root/.msf4/[/yellow]"
+                    )
         else:
             stderr = result.stderr.decode() if result.stderr else ""
             if "already" in stderr.lower():
@@ -386,7 +412,9 @@ def _ensure_msfdb_initialized(console):
     except subprocess.TimeoutExpired:
         console.print("  [yellow]⚠ msfdb init timed out (run manually)[/yellow]")
     except Exception as e:
-        console.print(f"  [yellow]⚠ Could not init MSF database: {str(e)[:40]}[/yellow]")
+        console.print(
+            f"  [yellow]⚠ Could not init MSF database: {str(e)[:40]}[/yellow]"
+        )
 
     console.print()
 
@@ -413,30 +441,42 @@ def _run_tool_setup_impl(check_only: bool = False, install_all: bool = False):
     # Header
     DesignSystem.clear_screen()
     console.print()
-    console.print("[bold cyan]╔══════════════════════════════════════════════════════════════╗[/bold cyan]")
-    console.print("[bold cyan]║              SOULEYEZ TOOL SETUP WIZARD                      ║[/bold cyan]")
-    console.print("[bold cyan]╚══════════════════════════════════════════════════════════════╝[/bold cyan]")
+    console.print(
+        "[bold cyan]╔══════════════════════════════════════════════════════════════╗[/bold cyan]"
+    )
+    console.print(
+        "[bold cyan]║              SOULEYEZ TOOL SETUP WIZARD                      ║[/bold cyan]"
+    )
+    console.print(
+        "[bold cyan]╚══════════════════════════════════════════════════════════════╝[/bold cyan]"
+    )
     console.print()
 
     # Distro detection
     distro_names = {
-        'kali': 'Kali Linux',
-        'parrot': 'Parrot OS',
-        'ubuntu': 'Ubuntu',
-        'debian': 'Debian',
-        'unknown': 'Unknown Linux'
+        "kali": "Kali Linux",
+        "parrot": "Parrot OS",
+        "ubuntu": "Ubuntu",
+        "debian": "Debian",
+        "unknown": "Unknown Linux",
     }
     console.print(f"  Detected OS: [bold]{distro_names.get(distro, distro)}[/bold]")
     console.print()
 
     # Show distro-specific messaging
-    if distro in ('kali', 'parrot'):
+    if distro in ("kali", "parrot"):
         console.print("  [green]✓ You're on a pentesting distro![/green]")
-        console.print("    Most tools are available via apt. Some may use pipx or direct download.")
+        console.print(
+            "    Most tools are available via apt. Some may use pipx or direct download."
+        )
         console.print()
-    elif distro in ('ubuntu', 'debian'):
-        console.print("  [yellow]Note:[/yellow] Some pentesting tools aren't in Ubuntu/Debian repos.")
-        console.print("  This wizard will install them using pipx, go, snap, or from source.")
+    elif distro in ("ubuntu", "debian"):
+        console.print(
+            "  [yellow]Note:[/yellow] Some pentesting tools aren't in Ubuntu/Debian repos."
+        )
+        console.print(
+            "  This wizard will install them using pipx, go, snap, or from source."
+        )
         console.print()
 
     _show_tool_status(console)
@@ -465,13 +505,18 @@ def _run_tool_setup_impl(check_only: bool = False, install_all: bool = False):
     _check_prerequisites(console, missing, distro)
 
     # Group tools by install method for smarter ordering
-    apt_tools = [t for t in missing if t['install_method'] == 'apt']
-    pipx_tools = [t for t in missing if 'pipx' in t['install']]
-    go_tools = [t for t in missing if 'go install' in t['install']]
-    gem_tools = [t for t in missing if 'gem install' in t['install']]
-    snap_tools = [t for t in missing if 'snap install' in t['install']]
-    git_tools = [t for t in missing if 'git clone' in t['install']]
-    other_tools = [t for t in missing if t not in apt_tools + pipx_tools + go_tools + gem_tools + snap_tools + git_tools]
+    apt_tools = [t for t in missing if t["install_method"] == "apt"]
+    pipx_tools = [t for t in missing if "pipx" in t["install"]]
+    go_tools = [t for t in missing if "go install" in t["install"]]
+    gem_tools = [t for t in missing if "gem install" in t["install"]]
+    snap_tools = [t for t in missing if "snap install" in t["install"]]
+    git_tools = [t for t in missing if "git clone" in t["install"]]
+    other_tools = [
+        t
+        for t in missing
+        if t
+        not in apt_tools + pipx_tools + go_tools + gem_tools + snap_tools + git_tools
+    ]
 
     total_to_install = len(missing)
     installed_count = 0
@@ -485,7 +530,7 @@ def _run_tool_setup_impl(check_only: bool = False, install_all: bool = False):
         if success:
             installed_count += len(apt_tools)
         else:
-            failed_tools.extend([t['name'] for t in apt_tools])
+            failed_tools.extend([t["name"] for t in apt_tools])
 
     # Install pipx tools
     if pipx_tools:
@@ -495,7 +540,7 @@ def _run_tool_setup_impl(check_only: bool = False, install_all: bool = False):
             if _install_pipx_tool(console, tool):
                 installed_count += 1
             else:
-                failed_tools.append(tool['name'])
+                failed_tools.append(tool["name"])
 
     # Install go tools
     if go_tools:
@@ -505,7 +550,7 @@ def _run_tool_setup_impl(check_only: bool = False, install_all: bool = False):
             if _install_go_tool(console, tool):
                 installed_count += 1
             else:
-                failed_tools.append(tool['name'])
+                failed_tools.append(tool["name"])
 
     # Install gem tools
     if gem_tools:
@@ -515,7 +560,7 @@ def _run_tool_setup_impl(check_only: bool = False, install_all: bool = False):
             if _install_gem_tool(console, tool):
                 installed_count += 1
             else:
-                failed_tools.append(tool['name'])
+                failed_tools.append(tool["name"])
 
     # Install snap tools
     if snap_tools:
@@ -525,7 +570,7 @@ def _run_tool_setup_impl(check_only: bool = False, install_all: bool = False):
             if _install_snap_tool(console, tool):
                 installed_count += 1
             else:
-                failed_tools.append(tool['name'])
+                failed_tools.append(tool["name"])
 
     # Install git-based tools
     if git_tools:
@@ -535,7 +580,7 @@ def _run_tool_setup_impl(check_only: bool = False, install_all: bool = False):
             if _install_git_tool(console, tool):
                 installed_count += 1
             else:
-                failed_tools.append(tool['name'])
+                failed_tools.append(tool["name"])
 
     # Install other tools (like metasploit)
     if other_tools:
@@ -545,7 +590,7 @@ def _run_tool_setup_impl(check_only: bool = False, install_all: bool = False):
             if _install_other_tool(console, tool):
                 installed_count += 1
             else:
-                failed_tools.append(tool['name'])
+                failed_tools.append(tool["name"])
 
     # Configure PATH in shell rc files (bash and zsh)
     _add_paths_to_shell_rc()
@@ -557,7 +602,9 @@ def _run_tool_setup_impl(check_only: bool = False, install_all: bool = False):
     console.print()
 
     if failed_tools:
-        console.print(f"  [yellow]⚠ {len(failed_tools)} tools failed to install:[/yellow]")
+        console.print(
+            f"  [yellow]⚠ {len(failed_tools)} tools failed to install:[/yellow]"
+        )
         for name in failed_tools:
             console.print(f"    • {name}")
         console.print()
@@ -585,7 +632,7 @@ def _run_post_install_tasks(console, distro: str):
     console.print()
     console.print("  [yellow]Important:[/yellow] To use newly installed tools, either:")
     console.print("    1. Restart your terminal, OR")
-    if distro in ('kali', 'parrot'):
+    if distro in ("kali", "parrot"):
         console.print("    2. Run: [cyan]source ~/.zshrc[/cyan]  (Kali uses zsh)")
     else:
         console.print("    2. Run: [cyan]source ~/.bashrc[/cyan]")
@@ -597,8 +644,12 @@ def _show_tool_status(console):
     tools_by_cat = get_tools_by_category()
     installed, total = get_tool_stats()
 
-    status_color = "green" if installed == total else "yellow" if installed > 0 else "red"
-    console.print(f"  [bold]Tool Status:[/bold] [{status_color}]{installed}/{total} installed[/{status_color}]")
+    status_color = (
+        "green" if installed == total else "yellow" if installed > 0 else "red"
+    )
+    console.print(
+        f"  [bold]Tool Status:[/bold] [{status_color}]{installed}/{total} installed[/{status_color}]"
+    )
     console.print()
 
     for category, tools in tools_by_cat.items():
@@ -606,12 +657,14 @@ def _show_tool_status(console):
         console.print(f"  [bold]{cat_name}[/bold]")
 
         for tool in tools:
-            if tool['installed']:
+            if tool["installed"]:
                 status = "[green]✓[/green]"
             else:
                 status = "[red]✗[/red]"
 
-            console.print(f"    {status} {tool['name']:<18} - {tool['description'][:40]}")
+            console.print(
+                f"    {status} {tool['name']:<18} - {tool['description'][:40]}"
+            )
 
         console.print()
 
@@ -621,32 +674,41 @@ def _check_prerequisites(console, missing_tools: List[Dict], distro: str):
     needed_prereqs = set()
 
     for tool in missing_tools:
-        install_cmd = tool['install']
-        if 'pipx' in install_cmd:
-            needed_prereqs.add('pipx')
+        install_cmd = tool["install"]
+        if "pipx" in install_cmd:
+            needed_prereqs.add("pipx")
             # pipx tools with native extensions need build dependencies
-            needed_prereqs.add('build-deps')
-        if 'go install' in install_cmd:
-            needed_prereqs.add('golang')
-        if 'gem install' in install_cmd:
-            needed_prereqs.add('ruby')
-        if 'snap install' in install_cmd:
-            needed_prereqs.add('snap')
-        if 'git clone' in install_cmd:
-            needed_prereqs.add('git')
+            needed_prereqs.add("build-deps")
+        if "go install" in install_cmd:
+            needed_prereqs.add("golang")
+        if "gem install" in install_cmd:
+            needed_prereqs.add("ruby")
+        if "snap install" in install_cmd:
+            needed_prereqs.add("snap")
+        if "git clone" in install_cmd:
+            needed_prereqs.add("git")
 
     missing_prereqs = []
     for prereq in needed_prereqs:
         info = PREREQUISITES[prereq]
         # Check if always_install flag is set, or if tool check fails
-        if info.get('always_install') or (info.get('check') and not check_tool(info['check'])):
+        if info.get("always_install") or (
+            info.get("check") and not check_tool(info["check"])
+        ):
             missing_prereqs.append((prereq, info))
 
     if not missing_prereqs:
         return
 
     # Sort to ensure build-deps comes first (needed before pipx installs)
-    prereq_order = {'build-deps': 0, 'pipx': 1, 'golang': 2, 'ruby': 3, 'snap': 4, 'git': 5}
+    prereq_order = {
+        "build-deps": 0,
+        "pipx": 1,
+        "golang": 2,
+        "ruby": 3,
+        "snap": 4,
+        "git": 5,
+    }
     missing_prereqs.sort(key=lambda x: prereq_order.get(x[0], 99))
 
     console.print()
@@ -654,12 +716,12 @@ def _check_prerequisites(console, missing_tools: List[Dict], distro: str):
 
     for prereq, info in missing_prereqs:
         console.print(f"    Installing {prereq}...", end=" ")
-        success, _, stderr = _run_command(info['install'], console, capture=True)
+        success, _, stderr = _run_command(info["install"], console, capture=True)
         if success:
             console.print("[green]✓[/green]")
 
             # Run pipx ensurepath if we just installed pipx
-            if prereq == 'pipx':
+            if prereq == "pipx":
                 subprocess.run("pipx ensurepath", shell=True, capture_output=True)
         else:
             console.print(f"[red]✗[/red] {stderr[:50]}")
@@ -672,14 +734,14 @@ def _install_apt_tools(console, tools: List[Dict]) -> bool:
     """Install tools available via apt."""
     packages = []
     for tool in tools:
-        cmd = tool['install']
-        if 'apt install' in cmd:
+        cmd = tool["install"]
+        if "apt install" in cmd:
             # Extract package name
             parts = cmd.split()
             for i, part in enumerate(parts):
-                if part == 'install' and i + 1 < len(parts):
+                if part == "install" and i + 1 < len(parts):
                     pkg = parts[i + 1]
-                    if not pkg.startswith('-'):
+                    if not pkg.startswith("-"):
                         packages.append(pkg)
                     break
 
@@ -700,8 +762,8 @@ def _install_apt_tools(console, tools: List[Dict]) -> bool:
 
 def _install_pipx_tool(console, tool: Dict) -> bool:
     """Install a tool using pipx."""
-    name = tool['name']
-    cmd = tool['install']
+    name = tool["name"]
+    cmd = tool["install"]
 
     console.print(f"    {name}...", end=" ")
 
@@ -724,8 +786,8 @@ def _install_pipx_tool(console, tool: Dict) -> bool:
 
 def _install_go_tool(console, tool: Dict) -> bool:
     """Install a tool using go install."""
-    name = tool['name']
-    cmd = tool['install']
+    name = tool["name"]
+    cmd = tool["install"]
 
     console.print(f"    {name}...", end=" ")
 
@@ -742,7 +804,7 @@ def _install_go_tool(console, tool: Dict) -> bool:
             capture_output=True,
             text=True,
             env=env,
-            timeout=300  # 5 minute timeout for go installs
+            timeout=300,  # 5 minute timeout for go installs
         )
         if result.returncode == 0:
             console.print("[green]✓[/green]")
@@ -759,8 +821,8 @@ def _install_go_tool(console, tool: Dict) -> bool:
 
 def _install_gem_tool(console, tool: Dict) -> bool:
     """Install a tool using gem."""
-    name = tool['name']
-    cmd = tool['install']
+    name = tool["name"]
+    cmd = tool["install"]
 
     console.print(f"    {name}...", end=" ")
 
@@ -778,8 +840,8 @@ def _install_gem_tool(console, tool: Dict) -> bool:
 
 def _install_snap_tool(console, tool: Dict) -> bool:
     """Install a tool using snap."""
-    name = tool['name']
-    cmd = tool['install']
+    name = tool["name"]
+    cmd = tool["install"]
 
     console.print(f"    {name}...", end=" ")
 
@@ -799,36 +861,52 @@ def _install_git_tool(console, tool: Dict) -> bool:
     """Install a tool from git (requires sudo for /opt)."""
     import re
 
-    name = tool['name']
-    cmd = tool['install']
+    name = tool["name"]
+    cmd = tool["install"]
 
     console.print(f"    {name}...")
 
     # Parse the command to handle existing directories properly
-    # Commands are typically: git clone <url> <dir> && pip install ... && ln -sf ...
-    commands = [c.strip() for c in cmd.split('&&')]
+    # Commands are typically: prereq && git clone <url> <dir> && pip install ... && ln -sf ...
+    commands = [c.strip() for c in cmd.split("&&")]
 
     clone_cmd = None
+    pre_clone_cmds = []
     post_clone_cmds = []
     target_dir = None
 
     for i, c in enumerate(commands):
-        if 'git clone' in c:
+        if "git clone" in c:
             clone_cmd = c
-            post_clone_cmds = commands[i + 1:]
+            pre_clone_cmds = commands[:i]  # Commands before git clone (e.g., cpan)
+            post_clone_cmds = commands[i + 1 :]
             # Extract target directory from clone command
             # Pattern: git clone <url> <directory>
-            match = re.search(r'git clone\s+\S+\s+(\S+)', c)
+            match = re.search(r"git clone\s+\S+\s+(\S+)", c)
             if match:
                 target_dir = match.group(1)
             break
 
     # If we found a git clone command and target directory
     if clone_cmd and target_dir:
+        # Run pre-clone commands first (e.g., installing dependencies like cpan)
+        for pre_cmd in pre_clone_cmds:
+            pre_cmd = pre_cmd.strip()
+            if not pre_cmd:
+                continue
+            console.print(f"      [dim]Running: {pre_cmd[:50]}...[/dim]")
+            success, _, stderr = _run_command(pre_cmd, console, capture=True)
+            if not success:
+                console.print(f"[red]✗[/red]")
+                if stderr:
+                    console.print(f"      [dim]{stderr[:80]}[/dim]")
+                return False
         dir_exists = Path(target_dir).exists()
 
         if dir_exists:
-            console.print(f"      [dim]Directory {target_dir} exists, updating...[/dim]")
+            console.print(
+                f"      [dim]Directory {target_dir} exists, updating...[/dim]"
+            )
             # Try to update with git pull
             pull_cmd = f"sudo git -C {target_dir} pull"
             success, _, stderr = _run_command(pull_cmd, console, capture=True)
@@ -846,7 +924,9 @@ def _install_git_tool(console, tool: Dict) -> bool:
                     return False
             elif not success:
                 # Pull failed for other reasons, try to continue anyway
-                console.print(f"      [yellow]⚠ git pull failed, continuing with existing files[/yellow]")
+                console.print(
+                    f"      [yellow]⚠ git pull failed, continuing with existing files[/yellow]"
+                )
         else:
             # Directory doesn't exist, run the clone
             success, _, stderr = _run_command(clone_cmd, console, capture=True)
@@ -886,23 +966,25 @@ def _install_git_tool(console, tool: Dict) -> bool:
 
 def _install_other_tool(console, tool: Dict) -> bool:
     """Install tools with custom installation methods (like metasploit)."""
-    name = tool['name']
-    cmd = tool['install']
+    name = tool["name"]
+    cmd = tool["install"]
 
     console.print(f"    {name}...", end=" ")
 
     # Special handling for metasploit installer (takes a while)
-    if 'msfinstall' in cmd:
+    if "msfinstall" in cmd:
         console.print()
-        console.print("      [yellow]Installing Metasploit (this may take several minutes)...[/yellow]")
-        console.print("      [dim]Installing postgresql and downloading Metasploit installer...[/dim]")
+        console.print(
+            "      [yellow]Installing Metasploit (this may take several minutes)...[/yellow]"
+        )
+        console.print(
+            "      [dim]Installing postgresql and downloading Metasploit installer...[/dim]"
+        )
 
         # Run the full install command (includes postgresql setup)
         try:
             result = subprocess.run(
-                cmd,
-                shell=True,
-                timeout=1800  # 30 minute timeout for metasploit
+                cmd, shell=True, timeout=1800  # 30 minute timeout for metasploit
             )
             if result.returncode == 0:
                 console.print("      [green]✓ Metasploit installed[/green]")
@@ -911,11 +993,11 @@ def _install_other_tool(console, tool: Dict) -> bool:
                 console.print("      [dim]Initializing MSF database...[/dim]")
                 try:
                     # Use full path since /opt/metasploit-framework/bin isn't in PATH yet
-                    msfdb_path = '/opt/metasploit-framework/bin/msfdb'
+                    msfdb_path = "/opt/metasploit-framework/bin/msfdb"
                     init_result = subprocess.run(
-                        [msfdb_path, 'init'],
+                        [msfdb_path, "init"],
                         capture_output=True,
-                        timeout=300  # 5 minute timeout
+                        timeout=300,  # 5 minute timeout
                     )
                     if init_result.returncode == 0:
                         console.print("      [green]✓ MSF database initialized[/green]")
@@ -924,30 +1006,48 @@ def _install_other_tool(console, tool: Dict) -> bool:
                         # msfdb init creates config in ~/.msf4/, but sudo looks in /root/.msf4/
                         import os
                         from pathlib import Path
-                        user_msf4 = Path.home() / '.msf4'
-                        user_db_yml = user_msf4 / 'database.yml'
+
+                        user_msf4 = Path.home() / ".msf4"
+                        user_db_yml = user_msf4 / "database.yml"
                         if user_db_yml.exists():
-                            console.print("      [dim]Configuring sudo access to MSF database...[/dim]")
+                            console.print(
+                                "      [dim]Configuring sudo access to MSF database...[/dim]"
+                            )
                             try:
                                 # Create /root/.msf4/ directory and copy database.yml
                                 copy_result = subprocess.run(
-                                    ['sudo', 'mkdir', '-p', '/root/.msf4'],
-                                    capture_output=True
+                                    ["sudo", "mkdir", "-p", "/root/.msf4"],
+                                    capture_output=True,
                                 )
                                 copy_result = subprocess.run(
-                                    ['sudo', 'cp', str(user_db_yml), '/root/.msf4/database.yml'],
-                                    capture_output=True
+                                    [
+                                        "sudo",
+                                        "cp",
+                                        str(user_db_yml),
+                                        "/root/.msf4/database.yml",
+                                    ],
+                                    capture_output=True,
                                 )
                                 if copy_result.returncode == 0:
-                                    console.print("      [green]✓ Sudo MSF access configured[/green]")
+                                    console.print(
+                                        "      [green]✓ Sudo MSF access configured[/green]"
+                                    )
                                 else:
-                                    console.print("      [yellow]⚠ Could not configure sudo access (run manually: sudo cp ~/.msf4/database.yml /root/.msf4/)[/yellow]")
+                                    console.print(
+                                        "      [yellow]⚠ Could not configure sudo access (run manually: sudo cp ~/.msf4/database.yml /root/.msf4/)[/yellow]"
+                                    )
                             except Exception as e:
-                                console.print(f"      [yellow]⚠ Could not configure sudo access: {str(e)[:30]}[/yellow]")
+                                console.print(
+                                    f"      [yellow]⚠ Could not configure sudo access: {str(e)[:30]}[/yellow]"
+                                )
                     else:
-                        console.print("      [yellow]⚠ MSF database init returned non-zero (may already be initialized)[/yellow]")
+                        console.print(
+                            "      [yellow]⚠ MSF database init returned non-zero (may already be initialized)[/yellow]"
+                        )
                 except Exception as e:
-                    console.print(f"      [yellow]⚠ Could not init MSF database: {str(e)[:40]}[/yellow]")
+                    console.print(
+                        f"      [yellow]⚠ Could not init MSF database: {str(e)[:40]}[/yellow]"
+                    )
 
                 return True
             else: