souleyez 2.43.12__py3-none-any.whl → 2.43.15__py3-none-any.whl

souleyez/__init__.py

@@ -1,2 +1,2 @@
-__version__ = '2.43.12'
+__version__ = '2.43.15'
 

souleyez/core/tool_chaining.py

@@ -4451,6 +4451,58 @@ class ToolChaining:
                         return job_ids
                 # === END Wildcard Auto-Retry ===
 
+                # === Host Redirect Auto-Retry Logic ===
+                # If gobuster detected a host-level redirect (e.g., non-www to www), auto-retry with corrected target
+                if parse_results.get('host_redirect_detected') and parse_results.get('redirect_target'):
+                    # Check if this is already a retry attempt (prevent loops)
+                    is_retry = job.get('metadata', {}).get('redirect_retry', False)
+
+                    if not is_retry:
+                        redirect_target = parse_results['redirect_target']
+                        original_target = target
+                        logger.info(f"🔄 Host redirect detected ({original_target} → {redirect_target}), creating auto-retry with corrected target")
+
+                        # Get original args and update the -u parameter with new target
+                        args = job.get('args', [])
+                        retry_args = []
+                        for i, arg in enumerate(args):
+                            if arg == '-u' and i + 1 < len(args):
+                                # Next arg is the URL, replace it
+                                retry_args.append(arg)
+                                retry_args.append(redirect_target)
+                                # Skip the next iteration since we handled it
+                            elif i > 0 and args[i - 1] == '-u':
+                                # This is the URL after -u, skip it (already handled)
+                                continue
+                            else:
+                                # Replace <target> placeholder if present
+                                retry_args.append(arg.replace(original_target, redirect_target) if original_target in arg else arg)
+
+                        # Build retry job command with corrected target
+                        retry_command = {
+                            'tool': 'gobuster',
+                            'target': redirect_target,
+                            'args': retry_args,
+                            'reason': f'Auto-retry: gobuster (host redirect detected: {original_target} → {redirect_target})',
+                            'metadata': {
+                                'redirect_retry': True,
+                                'retry_parent_job_id': job.get('id'),
+                                'original_target': original_target,
+                                'redirect_target': redirect_target
+                            }
+                        }
+
+                        # Enqueue the retry job
+                        retry_job_ids = self._enqueue_commands([retry_command], tool, engagement_id, redirect_target, parent_job_id=job.get('id'))
+                        if retry_job_ids:
+                            job_ids.extend(retry_job_ids)
+                            logger.info(f"✓ Retry job created with corrected target: {redirect_target}")
+
+                        # Skip further processing of this redirect scan
+                        # Let the retry job complete and process properly
+                        return job_ids
+                # === END Host Redirect Auto-Retry ===
+
                 # PHP/ASP files found → trigger SQLMap intelligently
                 # High-value targets get direct testing, others get base URL crawl
                 php_files = parse_results.get('php_files', [])
@@ -5041,6 +5093,57 @@ class ToolChaining:
                 return job_ids
             # === END Gobuster wildcard retry ===
 
+            # === Special handling for Gobuster host redirect retry ===
+            if tool == 'gobuster' and parse_results.get('host_redirect_detected'):
+                # Gobuster detected host-level redirect, auto-retry with corrected target
+                from souleyez.engine.background import enqueue_job
+                from souleyez.log_config import get_logger
+                logger = get_logger(__name__)
+
+                # Check if this is already a redirect retry (prevent loops)
+                is_redirect_retry = job.get('metadata', {}).get('redirect_retry', False)
+                if is_redirect_retry:
+                    logger.info(f"Gobuster host redirect: Already attempted redirect retry, skipping")
+                    return job_ids
+
+                # Get the redirect target
+                redirect_target = parse_results.get('redirect_target')
+                if not redirect_target:
+                    logger.warning(f"Gobuster host redirect detected but no redirect_target found")
+                    return job_ids
+
+                original_target = target
+                logger.info(f"Gobuster host redirect: Auto-retrying with corrected target {redirect_target}")
+
+                # Get original args and update the -u parameter with new target
+                job_args = job.get('args', [])
+                retry_args = []
+                for i, arg in enumerate(job_args):
+                    if arg == '-u' and i + 1 < len(job_args):
+                        retry_args.append(arg)
+                        retry_args.append(redirect_target)
+                    elif i > 0 and job_args[i - 1] == '-u':
+                        continue
+                    else:
+                        retry_args.append(arg.replace(original_target, redirect_target) if original_target in arg else arg)
+
+                retry_job_id = enqueue_job(
+                    tool='gobuster',
+                    target=redirect_target,
+                    args=retry_args,
+                    label=f"Auto-retry: gobuster (redirect → {redirect_target})",
+                    engagement_id=engagement_id,
+                    parent_id=job.get('id'),
+                    reason=f"Auto-triggered by gobuster: Host redirect detected ({original_target} → {redirect_target})",
+                    metadata={'redirect_retry': True, 'retry_parent_job_id': job.get('id'), 'original_target': original_target}
+                )
+
+                job_ids.append(retry_job_id)
+                logger.info(f"Created gobuster redirect retry job #{retry_job_id}")
+
+                return job_ids
+            # === END Gobuster host redirect retry ===
+
             # === Special handling for ffuf: Create SQLMap jobs and recursive ffuf scans ===
             if tool == 'ffuf':
                 from souleyez.engine.background import enqueue_job

souleyez/docs/README.md

@@ -1,6 +1,6 @@
 # SoulEyez Documentation
 
-**Version:** 2.43.12
+**Version:** 2.43.15
 **Last Updated:** January 12, 2026
 **Organization:** CyberSoul Security
 

souleyez/engine/result_handler.py

@@ -1218,12 +1218,27 @@ def parse_gobuster_job(engagement_id: int, log_path: str, job: Dict[str, Any]) -
                 exclude_length = length_match.group(1)
                 logger.info(f"Gobuster wildcard detected: Length {exclude_length}b")
 
+        # Check for host-level redirect (for auto-retry with corrected target)
+        host_redirect_detected = False
+        redirect_target = None
+
+        if "HOST_REDIRECT_TARGET:" in log_content:
+            host_redirect_detected = True
+            import re
+            redirect_match = re.search(r'HOST_REDIRECT_TARGET:\s*(\S+)', log_content)
+            if redirect_match:
+                redirect_target = redirect_match.group(1)
+                logger.info(f"Gobuster host redirect detected: {redirect_target}")
+
         # Check for gobuster errors
         gobuster_error = detect_tool_error(log_content, 'gobuster')
 
         # Determine status based on results
         if gobuster_error:
             status = STATUS_ERROR  # Tool failed to connect
+        elif host_redirect_detected:
+            # Host redirect detected - warning status (triggers auto-retry with corrected target)
+            status = STATUS_WARNING
         elif wildcard_detected:
             # Wildcard detected - warning status (triggers auto-retry)
             status = STATUS_WARNING
@@ -1255,6 +1270,12 @@ def parse_gobuster_job(engagement_id: int, log_path: str, job: Dict[str, Any]) -
             if exclude_length:
                 result['exclude_length'] = exclude_length
 
+        # Add host redirect info if detected
+        if host_redirect_detected:
+            result['host_redirect_detected'] = True
+            if redirect_target:
+                result['redirect_target'] = redirect_target
+
         return result
     except Exception as e:
         return {'error': str(e)}

souleyez/main.py

@@ -173,7 +173,7 @@ def _check_privileged_tools():
 
 
 @click.group()
-@click.version_option(version='2.43.12')
+@click.version_option(version='2.43.15')
 def cli():
     """SoulEyez - AI-Powered Pentesting Platform by CyberSoul Security"""
     from souleyez.log_config import init_logging

souleyez/parsers/dnsrecon_parser.py

@@ -57,7 +57,8 @@ def parse_dnsrecon_output(output: str, target: str = "") -> Dict[str, Any]:
             continue
 
         # Parse DNS records from dnsrecon output
-        # Old format: [*]   A cybersoulsecurity.com 198.185.159.144
+        # Format: [*]   A cybersoulsecurity.com 198.185.159.144 (info)
+        # Format: [+]   A www.vulnweb.com 44.228.249.3 (found records)
         # New format: 2026-01-08T13:50:16.302153-1000 INFO      SOA dns1.p01.nsone.net 198.51.44.1
         # New format: 2026-01-08T13:50:17.112742-1000 INFO      NS dns4.p01.nsone.net 198.51.45.65
 
@@ -65,8 +66,9 @@ def parse_dnsrecon_output(output: str, target: str = "") -> Dict[str, Any]:
         hostname = None
         ip = None
 
-        if line_stripped.startswith('[*]'):
-            # Old format: [*] <type> <hostname> <ip>
+        if line_stripped.startswith('[*]') or line_stripped.startswith('[+]'):
+            # Format: [*] or [+] <type> <hostname> <ip>
+            # [*] = informational, [+] = found/success
             parts = line_stripped.split()
             if len(parts) >= 4:
                 record_type = parts[1]

souleyez/plugins/gobuster.py

@@ -239,18 +239,25 @@ class GobusterPlugin(PluginBase):
         This causes gobuster to fail or produce false positives. We detect this
         upfront and auto-add --exclude-length to filter them out.
 
+        Also detects host-level redirects (e.g., non-www to www) and warns the user.
+
         Returns:
             dict with keys:
                 - exclude_length: str or None (response length to exclude)
                 - exclude_status: str or None (status code detected)
                 - reason: str or None (explanation)
+                - redirect_host: str or None (suggested target if host redirect detected)
         """
-        result = {'exclude_length': None, 'exclude_status': None, 'reason': None}
+        result = {'exclude_length': None, 'exclude_status': None, 'reason': None, 'redirect_host': None}
 
         # Generate random UUID path that definitely doesn't exist
         test_path = str(uuid.uuid4())
         test_url = f"{base_url.rstrip('/')}/{test_path}"
 
+        # Parse the original target host for comparison
+        original_parsed = urlparse(base_url)
+        original_host = original_parsed.netloc.lower()
+
         try:
             resp = requests.get(
                 test_url,
@@ -263,6 +270,46 @@ class GobusterPlugin(PluginBase):
             if resp.status_code == 404:
                 return result
 
+            # Check for host-level redirects (301/302/307/308)
+            if resp.status_code in [301, 302, 307, 308]:
+                location = resp.headers.get('Location', '')
+                if location:
+                    # Parse the redirect location
+                    redirect_parsed = urlparse(location)
+                    redirect_host = redirect_parsed.netloc.lower()
+
+                    # If Location is relative, it's not a host redirect
+                    if redirect_host and redirect_host != original_host:
+                        # This is a host-level redirect (e.g., non-www to www)
+                        suggested_url = f"{redirect_parsed.scheme or original_parsed.scheme}://{redirect_host}"
+                        result['redirect_host'] = suggested_url
+                        result['exclude_status'] = str(resp.status_code)
+                        result['reason'] = (
+                            f"Host redirect detected: {original_host} → {redirect_host}"
+                        )
+
+                        if log_path:
+                            with open(log_path, 'a') as f:
+                                f.write(f"\n{'=' * 70}\n")
+                                f.write("⚠️  HOST-LEVEL REDIRECT DETECTED\n")
+                                f.write(f"{'=' * 70}\n")
+                                f.write(f"Target: {base_url}\n")
+                                f.write(f"Redirects to: {redirect_host}\n")
+                                f.write(f"Status: {resp.status_code}\n\n")
+                                f.write("The server redirects ALL requests to a different host.\n")
+                                f.write("This causes unreliable results because:\n")
+                                f.write("  - Response sizes vary based on path length in redirect URL\n")
+                                f.write("  - Gobuster may report false positives or miss real paths\n\n")
+                                # Parseable marker for auto-retry
+                                f.write(f"HOST_REDIRECT_TARGET: {suggested_url}\n\n")
+                                f.write("Auto-retrying with corrected target...\n")
+                                f.write(f"{'=' * 70}\n\n")
+
+                        # Still try to exclude the response length for this scan
+                        content_length = len(resp.content)
+                        result['exclude_length'] = str(content_length)
+                        return result
+
             # Any other status for a random UUID = false positive indicator
             # Common: 403 (blocked), 401 (auth required), 200 (catch-all), 500 (error page)
             if resp.status_code in [200, 301, 302, 400, 401, 403, 500, 503]:

souleyez/ui/wordlist_browser.py

@@ -0,0 +1,481 @@
+#!/usr/bin/env python3
+"""
+souleyez.ui.wordlist_browser - Interactive wordlist browser with keyboard navigation
+
+Discovers wordlists from common directories (SecLists, Kali, etc.) and provides
+an interactive browser for selection.
+"""
+import os
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+import click
+from rich.console import Console
+from rich.table import Table
+
+from souleyez.ui.design_system import DesignSystem
+from souleyez.ui.interactive_selector import _get_key, KEY_UP, KEY_DOWN, KEY_ENTER, KEY_ESCAPE
+
+# Common wordlist directories to scan
+WORDLIST_DIRECTORIES: List[Tuple[str, str]] = [
+    # SoulEyez built-in (highest priority)
+    ('SoulEyez', '~/.souleyez/data/wordlists'),
+    # Kali/Parrot Linux
+    ('System', '/usr/share/wordlists'),
+    # SecLists - various install locations
+    ('SecLists', '/usr/share/seclists'),
+    ('SecLists', '/opt/SecLists'),
+    ('SecLists', '/opt/seclists'),
+    ('SecLists', '~/SecLists'),
+    # Metasploit
+    ('Metasploit', '/usr/share/metasploit-framework/data/wordlists'),
+    # Dirb
+    ('Dirb', '/usr/share/dirb/wordlists'),
+    # Dirbuster
+    ('Dirbuster', '/usr/share/dirbuster/wordlists'),
+]
+
+# Category detection patterns - ORDER MATTERS (more specific first)
+# Each pattern is checked against the full path + filename
+CATEGORY_PATTERNS = {
+    # DNS/Subdomain - check first since "subdomain" is specific
+    'dns': [
+        'subdomain', 'dns', 'vhost', 'hostname'
+    ],
+    # Extensions
+    'extensions': [
+        'extension', 'ext.', 'suffix', 'filetype'
+    ],
+    # Fuzzing
+    'fuzzing': [
+        'fuzz', 'injection', 'xss', 'sqli', 'lfi', 'rfi', 'traversal'
+    ],
+    # Users - be specific to avoid matching "username" in paths
+    'users': [
+        'users.txt', 'usernames', 'user_', '_user', 'logins', 'accounts',
+        '/users/', '/usernames/'
+    ],
+    # Passwords - check before dirs
+    'passwords': [
+        'password', 'pass.txt', 'passwd', 'credential', 'rockyou',
+        'darkweb', 'leaked', '/passwords/'
+    ],
+    # Directories - last since patterns are more generic
+    'dirs': [
+        'directory', 'dirs', 'dir-', 'web-content', 'web_content',
+        'dirbuster', '/dirb/', 'raft-', 'apache.txt', 'iis.txt'
+    ],
+}
+
+
+def detect_category(path: str, name: str) -> str:
+    """
+    Detect wordlist category from path and filename.
+
+    Args:
+        path: Full path to wordlist
+        name: Filename
+
+    Returns:
+        Category string: 'dirs', 'dns', 'passwords', 'users', 'fuzzing', 'extensions', or 'other'
+    """
+    path_lower = path.lower()
+    name_lower = name.lower()
+    combined = f"{path_lower}/{name_lower}"
+
+    for category, patterns in CATEGORY_PATTERNS.items():
+        for pattern in patterns:
+            if pattern in combined:
+                return category
+
+    return 'other'
+
+
+def count_lines(filepath: str, max_count: int = 1000000) -> int:
+    """
+    Count lines in a file efficiently.
+
+    Args:
+        filepath: Path to file
+        max_count: Stop counting after this many lines
+
+    Returns:
+        Line count (or max_count if exceeded)
+    """
+    try:
+        count = 0
+        with open(filepath, 'r', encoding='utf-8', errors='ignore') as f:
+            for _ in f:
+                count += 1
+                if count >= max_count:
+                    return max_count
+        return count
+    except Exception:
+        return 0
+
+
+def discover_all_wordlists(category_filter: Optional[str] = None) -> List[Dict[str, Any]]:
+    """
+    Discover all wordlists from known directories.
+
+    Args:
+        category_filter: Optional category to filter by ('dirs', 'dns', 'passwords', etc.)
+
+    Returns:
+        List of wordlist dicts with: path, name, source, category, entries, size_mb
+    """
+    wordlists = []
+    seen_paths = set()
+
+    for source, directory in WORDLIST_DIRECTORIES:
+        dir_path = os.path.expanduser(directory)
+
+        if not os.path.isdir(dir_path):
+            continue
+
+        # Walk directory tree
+        for root, _, files in os.walk(dir_path):
+            for filename in files:
+                # Skip non-text files
+                if not filename.endswith(('.txt', '.lst', '.dic', '.wordlist')):
+                    # Also include files without extension if they look like wordlists
+                    if '.' in filename:
+                        continue
+
+                filepath = os.path.join(root, filename)
+
+                # Skip if already seen (handles duplicate paths)
+                if filepath in seen_paths:
+                    continue
+                seen_paths.add(filepath)
+
+                # Get relative path from source directory for display
+                rel_path = os.path.relpath(filepath, dir_path)
+
+                # Detect category
+                category = detect_category(filepath, filename)
+
+                # Apply category filter
+                if category_filter and category != category_filter:
+                    # Also check if filter matches 'other' for unmatched
+                    if category_filter != 'all':
+                        continue
+
+                # Get file stats
+                try:
+                    stat = os.stat(filepath)
+                    size_mb = stat.st_size / (1024 * 1024)
+                except Exception:
+                    size_mb = 0
+
+                # Count entries (limit to avoid slow scans on huge files)
+                if size_mb < 50:  # Only count for files under 50MB
+                    entries = count_lines(filepath)
+                else:
+                    entries = -1  # Will display as "large"
+
+                wordlists.append({
+                    'path': filepath,
+                    'name': filename,
+                    'rel_path': rel_path,
+                    'source': source,
+                    'category': category,
+                    'entries': entries,
+                    'size_mb': size_mb,
+                })
+
+    # Sort: SoulEyez first, then by source, then by name
+    def sort_key(w):
+        source_order = {
+            'SoulEyez': 0,
+            'SecLists': 1,
+            'System': 2,
+            'Dirb': 3,
+            'Dirbuster': 4,
+            'Metasploit': 5,
+        }
+        return (source_order.get(w['source'], 99), w['name'].lower())
+
+    wordlists.sort(key=sort_key)
+
+    return wordlists
+
+
+class WordlistBrowser:
+    """
+    Interactive single-select browser for wordlists.
+
+    Based on InteractiveSelector but for single selection:
+    - Enter selects highlighted item (no checkboxes)
+    - Tab cycles category filter
+    - / starts search mode
+    """
+
+    CURSOR = '>'
+    CATEGORIES = ['all', 'dirs', 'dns', 'passwords', 'users', 'fuzzing', 'other']
+
+    def __init__(
+        self,
+        category_filter: Optional[str] = None,
+        title: str = 'WORDLIST BROWSER'
+    ):
+        """
+        Initialize the wordlist browser.
+
+        Args:
+            category_filter: Initial category filter
+            title: Title to display
+        """
+        self.title = title
+        self.suggested_category = category_filter  # Remember suggested filter
+        self.category_idx = 0  # Start with 'all' so users see everything
+
+        self.search_query = ''
+        self.search_mode = False
+        self.all_wordlists = discover_all_wordlists()
+        self.filtered = self._apply_filter()
+        self.cursor_pos = 0
+        self.page_start = 0
+        self.page_size = 15
+        self.console = Console()
+        self.running = True
+
+    def _apply_filter(self) -> List[Dict[str, Any]]:
+        """Apply current category filter and search query."""
+        category = self.CATEGORIES[self.category_idx]
+        filtered = self.all_wordlists
+
+        # Apply category filter
+        if category != 'all':
+            filtered = [w for w in filtered if w['category'] == category]
+
+        # Apply search query
+        if self.search_query:
+            query = self.search_query.lower()
+            filtered = [w for w in filtered if query in w['name'].lower() or query in w['rel_path'].lower()]
+
+        return filtered
+
+    def run(self) -> Optional[str]:
+        """
+        Run the interactive browser.
+
+        Returns:
+            Selected wordlist path or None if cancelled
+        """
+        if not self.all_wordlists:
+            click.echo(click.style("  No wordlists found in common directories.", fg='yellow'))
+            click.pause()
+            return None
+
+        self.running = True
+
+        while self.running:
+            self._render()
+            key = _get_key()
+            result = self._handle_key(key)
+            if result is not None:
+                return result
+
+        return None
+
+    def _render(self):
+        """Render the browser UI."""
+        from rich.table import Table
+        from rich import box
+
+        DesignSystem.clear_screen()
+        width = DesignSystem.get_terminal_width()
+
+        # Title bar - box style like InteractiveSelector
+        click.echo()
+        click.echo("┌" + "─" * (width - 2) + "┐")
+        category = self.CATEGORIES[self.category_idx]
+        filter_text = f"Filter: {category}"
+        title_text = f" {self.title} "
+        padding = width - len(title_text) - len(filter_text) - 4
+        left_pad = padding // 2
+        right_pad = padding - left_pad
+        click.echo("│" + " " * left_pad + click.style(title_text, bold=True, fg='cyan') +
+                   " " * right_pad + click.style(filter_text, fg='yellow') + " │")
+        click.echo("└" + "─" * (width - 2) + "┘")
+        click.echo()
+
+        # Search bar
+        if self.search_mode:
+            click.echo(f"  Search: {click.style(self.search_query + '_', fg='cyan')}")
+        elif self.search_query:
+            click.echo(f"  Search: {click.style(self.search_query, fg='cyan')} (press / to edit)")
+
+        # Stats
+        total = len(self.filtered)
+        click.echo(f"  {click.style('Total:', bold=True)} {total} wordlists")
+        click.echo()
+
+        if not self.filtered:
+            click.echo(click.style("  No wordlists match current filter.", fg='yellow'))
+            click.echo()
+        else:
+            # Calculate visible items
+            page_end = min(self.page_start + self.page_size, len(self.filtered))
+            visible = self.filtered[self.page_start:page_end]
+
+            # Create table like InteractiveSelector
+            table = Table(
+                show_header=True,
+                header_style="bold cyan",
+                box=DesignSystem.TABLE_BOX,
+                padding=(0, 1),
+                expand=True
+            )
+
+            # Add columns
+            table.add_column(" ", width=2, justify="center", no_wrap=True)  # Cursor
+            table.add_column("Name", no_wrap=True)
+            table.add_column("Entries", width=12, justify="right")
+            table.add_column("Source", width=12)
+            table.add_column("Category", width=12)
+
+            # Add rows
+            for idx, wordlist in enumerate(visible):
+                absolute_idx = self.page_start + idx
+                is_cursor = (absolute_idx == self.cursor_pos)
+
+                # Cursor indicator
+                cursor = "▶" if is_cursor else " "
+
+                # Name - use rel_path if it has subdirs
+                name = wordlist['rel_path'] if '/' in wordlist['rel_path'] else wordlist['name']
+                if len(name) > 45:
+                    name = '...' + name[-42:]
+
+                # Entry count
+                if wordlist['entries'] == -1:
+                    entries_str = 'large'
+                elif wordlist['entries'] >= 1000000:
+                    entries_str = f"{wordlist['entries'] / 1000000:.1f}M"
+                elif wordlist['entries'] >= 1000:
+                    entries_str = f"{wordlist['entries'] / 1000:.1f}K"
+                else:
+                    entries_str = str(wordlist['entries'])
+
+                # Source color
+                source = wordlist['source']
+
+                # Category
+                cat = wordlist['category']
+
+                # Add row with highlight for cursor
+                if is_cursor:
+                    table.add_row(cursor, name, entries_str, source, cat, style="reverse")
+                else:
+                    table.add_row(cursor, name, entries_str, source, cat)
+
+            self.console.print(table)
+
+            # Pagination
+            if len(self.filtered) > self.page_size:
+                page_num = (self.page_start // self.page_size) + 1
+                total_pages = (len(self.filtered) + self.page_size - 1) // self.page_size
+                click.echo()
+                click.echo(f"  Page {page_num}/{total_pages}")
+
+        # Help bar
+        click.echo()
+        click.echo(DesignSystem.separator())
+        help_text = (
+            f"  {click.style('↑↓/jk:', bold=True)} Navigate  |  "
+            f"{click.style('Enter:', bold=True)} Select  |  "
+            f"{click.style('/:', bold=True)} Search  |  "
+            f"{click.style('Tab:', bold=True)} Filter  |  "
+            f"{click.style('q:', bold=True)} Back"
+        )
+        click.echo(help_text)
+        click.echo(DesignSystem.separator())
+
+    def _handle_key(self, key: str) -> Optional[str]:
+        """
+        Handle a keypress.
+
+        Returns:
+            Selected path if Enter pressed, None otherwise
+        """
+        # Search mode - capture text
+        if self.search_mode:
+            if key == KEY_ENTER or key == '\r' or key == '\n':
+                self.search_mode = False
+                self.filtered = self._apply_filter()
+                self.cursor_pos = 0
+                self.page_start = 0
+            elif key == KEY_ESCAPE:
+                self.search_mode = False
+                self.search_query = ''
+                self.filtered = self._apply_filter()
+                self.cursor_pos = 0
+                self.page_start = 0
+            elif key in ('\x7f', '\x08'):  # Backspace
+                self.search_query = self.search_query[:-1]
+                self.filtered = self._apply_filter()
+                self.cursor_pos = 0
+                self.page_start = 0
+            elif len(key) == 1 and key.isprintable():
+                self.search_query += key
+                self.filtered = self._apply_filter()
+                self.cursor_pos = 0
+                self.page_start = 0
+            return None
+
+        # Navigation - Up
+        if key in (KEY_UP, 'k'):
+            if self.cursor_pos > 0:
+                self.cursor_pos -= 1
+                if self.cursor_pos < self.page_start:
+                    self.page_start = max(0, self.page_start - self.page_size)
+
+        # Navigation - Down
+        elif key in (KEY_DOWN, 'j'):
+            if self.filtered and self.cursor_pos < len(self.filtered) - 1:
+                self.cursor_pos += 1
+                if self.cursor_pos >= self.page_start + self.page_size:
+                    self.page_start += self.page_size
+
+        # Select - Enter
+        elif key in (KEY_ENTER, '\r', '\n'):
+            if self.filtered:
+                return self.filtered[self.cursor_pos]['path']
+
+        # Search mode
+        elif key == '/':
+            self.search_mode = True
+
+        # Cycle category filter - Tab
+        elif key == '\t':
+            self.category_idx = (self.category_idx + 1) % len(self.CATEGORIES)
+            self.filtered = self._apply_filter()
+            self.cursor_pos = 0
+            self.page_start = 0
+
+        # Exit
+        elif key in (KEY_ESCAPE, 'q', '\x03'):  # \x03 is Ctrl+C
+            self.running = False
+
+        return None
+
+
+def browse_wordlists(category_filter: Optional[str] = None, title: str = 'WORDLIST BROWSER') -> Optional[str]:
+    """
+    Launch the interactive wordlist browser.
+
+    Args:
+        category_filter: Optional initial category filter
+        title: Browser title
+
+    Returns:
+        Selected wordlist path or None if cancelled
+    """
+    browser = WordlistBrowser(category_filter=category_filter, title=title)
+    return browser.run()
+
+
+# Convenience export
+__all__ = ['browse_wordlists', 'discover_all_wordlists', 'WordlistBrowser', 'WORDLIST_DIRECTORIES']

souleyez/wordlists.py

@@ -391,6 +391,11 @@ def display_wordlist_menu(tool_name, category, title="Wordlist Selection"):
                 idx += 1
         click.echo()
     
+    # Browse all wordlists option
+    click.echo(f"  {idx}. Browse all wordlists...")
+    browse_idx = idx
+    idx += 1
+
     # Dynamic label based on category
     single_label = "Enter single username" if category == 'users' else "Enter single password" if category == 'passwords' else "Enter single value"
 
@@ -411,6 +416,13 @@ def display_wordlist_menu(tool_name, category, title="Wordlist Selection"):
             selected = choice_map[choice]
             click.echo(click.style(f"✓ Selected: {selected}", fg='green'))
             return selected
+        elif choice == browse_idx:
+            # Launch interactive wordlist browser
+            from souleyez.ui.wordlist_browser import browse_wordlists
+            selected = browse_wordlists(category_filter=category, title=f'SELECT {category.upper()} WORDLIST')
+            if selected:
+                click.echo(click.style(f"✓ Selected: {selected}", fg='green'))
+            return selected
         elif choice == single_idx:
             # Single value entry - return tuple to indicate it's not a file
             value_prompt = "Enter username" if category == 'users' else "Enter password" if category == 'passwords' else "Enter value"

{souleyez-2.43.12.dist-info → souleyez-2.43.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: souleyez
-Version: 2.43.12
+Version: 2.43.15
 Summary: AI-Powered Penetration Testing Platform with 40+ integrated tools
 Author-email: CyberSoul Security <contact@cybersoulsecurity.com>
 Maintainer-email: CyberSoul Security <contact@cybersoulsecurity.com>

{souleyez-2.43.12.dist-info → souleyez-2.43.15.dist-info}/RECORD

@@ -1,15 +1,15 @@
-souleyez/__init__.py,sha256=AqWvRvGm0eblSfTChQBR6xzyVh0aeRZjPSgASWfhVEk,25
+souleyez/__init__.py,sha256=slnfvvkWKYSrEzjlUbRNn3eLdpvlqHX0-gUtgkJAmx4,25
 souleyez/config.py,sha256=av357I3GYRWAklv8Dto-9-5Db699Wq5znez7zo7241Q,11595
 souleyez/devtools.py,sha256=rptmUY4a5eVvYjdEc6273MSagL-D9xibPOFgohVqUno,3508
 souleyez/feature_flags.py,sha256=mo6YAq07lc6sR3lEFKmIwTKxXZ2JPxwa5X97uR_mu50,4642
 souleyez/history.py,sha256=gzs5I_j-3OigIP6yfmBChdqxaFmyUIxvTpzWUPe_Q6c,2853
 souleyez/log_config.py,sha256=MMhPAJOqgXDfuE-xm5g0RxAfWndcmbhFHvIEMm1a_Wo,5830
-souleyez/main.py,sha256=LfDxtOn9W1BOHPoIlAq9P46-hfl0m_YYiqSNpMhD3ng,129101
+souleyez/main.py,sha256=MKgVu0VaYdNpZsq0MWFNz33uX3P8MWwennF_2gmDjPQ,129101
 souleyez/scanner.py,sha256=U3IWHRrJ5aQ32dSHiVAHB60w1R_z0E0QxfM99msYNlw,3124
 souleyez/security.py,sha256=S84m1QmnKz_6NgH2I6IBIAorMHxRPNYVFSnks5xjihQ,2479
 souleyez/ui.py,sha256=15pfsqoDPnojAqr5S0TZHJE2ZkSHzkHpNVfVvsRj66A,34301
 souleyez/utils.py,sha256=2IbIwzBmGm4_vVvPl9YV1ExS2dxhVS8SGVClvuWKuZI,2721
-souleyez/wordlists.py,sha256=u_2pcRqTKNfzg_w-1kUUOcX33IjyunptFtNmx6m8HGU,15815
+souleyez/wordlists.py,sha256=xzWOOIPnfVlx3Zeq5dUYDZBW0gBxVX3BRxksTcYcinA,16336
 souleyez/ai/__init__.py,sha256=7C4wIQX8gL5HksjKvyh3yp-XMiMnqIH8UWAF5zn6B2I,908
 souleyez/ai/action_mapper.py,sha256=YdTNV1ylzovJKAROEhArlgGLsH6iyO6ll15My-ILVn8,17587
 souleyez/ai/chain_advisor.py,sha256=3I94rKIG3yGsJ-16MWAnWPMjIvR0Tl57JZjzSf58xDg,16617
@@ -59,7 +59,7 @@ souleyez/core/network_utils.py,sha256=-4WgUE91RBzyXDFgGTxMa0zsWowJ47cEOAKXNeVa-W
 souleyez/core/parser_handler.py,sha256=cyZtEDctqMdWgubsU0Jg6o4XqBgyfaJ_AeBHQmmv4hM,5564
 souleyez/core/pending_chains.py,sha256=Dnka7JK7A8gTWCGpTu6qrIgIDIXprkZmwJ0Rm2oWqRE,10972
 souleyez/core/templates.py,sha256=DzlXlAz8_lwAFjjUWPp3r81KCCzbNeK-bkN1IlgQBSU,18112
-souleyez/core/tool_chaining.py,sha256=x1cJ6icuWu5YBZJ31q_Jm2iahGC3mBoUCnfYrkT0Kcc,281598
+souleyez/core/tool_chaining.py,sha256=LLrCUwVelZHP7N6yso-fcIJbDVbDJDcPKRQlFx6JIu0,287404
 souleyez/core/version_utils.py,sha256=UOrOa3qfUdLKdzWT6GAGNV9TauwinXyLyelS8sOk0eE,11769
 souleyez/core/vuln_correlation.py,sha256=U69MSI5I-AtiyOAbXohGDKMpEHRW9y4G_0M1ppRGX18,14765
 souleyez/core/web_utils.py,sha256=f-Dqa6tH8ROnygn6-k7J1y8Qz2f1FmeJnPjPE0WRn34,4902
@@ -104,7 +104,7 @@ souleyez/detection/__init__.py,sha256=QIhvXjFdjrquQ6A0VQ7GZQkK_EXB59t8Dv9PKXhEUe
 souleyez/detection/attack_signatures.py,sha256=akgWwiIkh6WYnghCuLhRV0y6FS0SQ0caGF8tZUc49oA,6965
 souleyez/detection/mitre_mappings.py,sha256=xejE80YK-g8kKaeQoo-vBl8P3t8RTTItbfN0NaVZw6s,20558
 souleyez/detection/validator.py,sha256=-AJ7QSJ3-6jFKLnPG_Rc34IXyF4JPyI82BFUgTA9zw0,15641
-souleyez/docs/README.md,sha256=1tbpTWjDcVQqP3DrVth28HR5bq9jAWccaUwtksG1lNk,7188
+souleyez/docs/README.md,sha256=hjhVK2ZaTUOWQWCum2agdKB_VL5O9FRLe74xMT2k-Xw,7188
 souleyez/docs/api-reference/cli-commands.md,sha256=lTLFnILN3YRVdqCaag7WgsYXfDGglb1TuPexkxDsVdE,12917
 souleyez/docs/api-reference/engagement-api.md,sha256=nd-EvQMtiJrobg2bzFEADp853HP1Uhb9dmgok0_-neE,11672
 souleyez/docs/api-reference/integration-guide.md,sha256=c96uX79ukHyYotLa54wZ20Kx-EUZnrKegTeGkfLD-pw,16285
@@ -152,7 +152,7 @@ souleyez/engine/job_status.py,sha256=OAEf2rAzapm55m4tc3PSilotdA5ONX15JavUMLre0is
 souleyez/engine/loader.py,sha256=ke6QQVVWozDnqGNBotajC3RBYOa2_DZmv5DAnDZVgIc,2769
 souleyez/engine/log_sanitizer.py,sha256=QHF6zSms-wHo6SbL6fHXIh1GG-8G34lE7kl45nbPn70,7130
 souleyez/engine/manager.py,sha256=aBQMoib-VWNXtIp5Qn34tRj1P1jiLpwAIoo1fexAaLU,3629
-souleyez/engine/result_handler.py,sha256=eD5fqGAlnG0pr1gxhKB40HBw_uyzsFJZpFaTDeMXc1g,142535
+souleyez/engine/result_handler.py,sha256=jioWzfRrSdRP7vfrcGIujrhh6-H1POkyiBGDnwjoW9I,143455
 souleyez/engine/worker_manager.py,sha256=B7b8RbkKTNofmiIyHTNgdikoZCLXpB-iIl1S4-U3q9o,6127
 souleyez/export/__init__.py,sha256=2kFHftSqqrRUG6PhtfhCyhnkpkjc-8Zb4utGo-Nb6B4,61
 souleyez/export/evidence_bundle.py,sha256=hqPn_h2CidhL-1VAT0qraZ8r1yfnUTnLZ3RfPPCK5Ds,9966
@@ -195,7 +195,7 @@ souleyez/parsers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,
 souleyez/parsers/bloodhound_parser.py,sha256=r1f5ePsuPc90CJOySnZ6WkfYQoeVJWraTiE7dnI8BbI,3134
 souleyez/parsers/crackmapexec_parser.py,sha256=HN3nCBMdCEoP1OuYPLmf080b2YmMphZ7Wtm1ByrKGu0,10849
 souleyez/parsers/dalfox_parser.py,sha256=w_eCeyL-Eu9zGyXqYmq0XKbnOIR7lnDD-zbRT7SPco0,6856
-souleyez/parsers/dnsrecon_parser.py,sha256=zy9_d-dxVSWSSNy7UgMQ2J_r8uoPacHiAMwkAjomXcM,7885
+souleyez/parsers/dnsrecon_parser.py,sha256=_j_xE94OAEffhH8YZWQ-lKXlcUVlhTaPHwGcwDBjY5I,8052
 souleyez/parsers/enum4linux_parser.py,sha256=8C9VQ0f-VzKFBkRmScPM84Q8CYvPwidBuQFLH2TJ48c,17728
 souleyez/parsers/ffuf_parser.py,sha256=xoLicqbwjgJqMrkGEyUFmBIx1Jn7t2OG7OtXkN-wvUE,1706
 souleyez/parsers/gobuster_parser.py,sha256=-DS8fpA7uoSKhrGnoMdjowhl7OcitAPoEee-LXiogYs,5960
@@ -227,7 +227,7 @@ souleyez/plugins/dnsrecon.py,sha256=nxeVgwACUyw5VYEyD-5U277d1U72EkWBX9nR9_DMZrI,
 souleyez/plugins/enum4linux.py,sha256=VHkKPs8PWX90RLsGdYt5Ieuc3Sz52fbeWvKCL1KquIY,10876
 souleyez/plugins/ffuf.py,sha256=7c1-Q7xXTMmH_2wHXikjmZnSgZL13Hj5E_asBxZ6Y5U,11652
 souleyez/plugins/firmware_extract.py,sha256=_hZXx6cHb9noM6uVgi3hwrJLw8hE9mDUelTEHwoIdCU,6460
-souleyez/plugins/gobuster.py,sha256=GMTUyfkVnZ2gp3kh_R-KQ4EIGEBX5fxBIMfHZrwkVFo,29285
+souleyez/plugins/gobuster.py,sha256=y8QeEjMR5_2tf-T63nxFRUtWmlCzrPez2I4nLqPNOfY,32114
 souleyez/plugins/hashcat.py,sha256=aigfwBu9IorXKgbyEIWx0qOCEdr1wnZaPqdYwh0PITc,10381
 souleyez/plugins/http_fingerprint.py,sha256=_D5UVAtDC0f-uy4pQcBI43c4jnsJ5wyvCIvttUiVurw,21202
 souleyez/plugins/hydra.py,sha256=kfVJwgh3x1DC0wEtA-lkoY7qhQH1qKViYexUECZSPY4,29520
@@ -368,11 +368,12 @@ souleyez/ui/tool_setup.py,sha256=HkRTjzN7FHUs_XKtNYnphkdXb5kC4P6ghpI8TeCuEjU,363
 souleyez/ui/tutorial.py,sha256=efDF6nWRek6fySppjmq3qMQ3J2WfW89LOcaeltqnWH4,14917
 souleyez/ui/tutorial_state.py,sha256=Thf7_qCj4VKjG7UqgJqa9kjIqiFUU-7Q7kG4v-u2B4A,8123
 souleyez/ui/wazuh_vulns_view.py,sha256=3vJJEmrjgS2wD6EDB7ZV7WxgytBHTm-1WqNDjp7lVEI,21830
+souleyez/ui/wordlist_browser.py,sha256=iQ2YYxrVo8FGCfM-Bc0teVBijSAbd2rjbSQ2hOE7eiY,16110
 souleyez/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 souleyez/utils/tool_checker.py,sha256=YzNajZpFyKJA5fp0Kq_gQ0YnKb7J1BaKJSZ8vP-IWj8,30868
-souleyez-2.43.12.dist-info/licenses/LICENSE,sha256=J7vDD5QMF4w2oSDm35eBgosATE70ah1M40u9W4EpTZs,1090
-souleyez-2.43.12.dist-info/METADATA,sha256=BqwnW_Lm4R-T_rhGCK7rBhZBfsXvgDSSjWbiClza5X4,10426
-souleyez-2.43.12.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-souleyez-2.43.12.dist-info/entry_points.txt,sha256=bN5W1dhjDZJl3TKclMjRpfQvGPmyrJLwwDuCj_X39HE,48
-souleyez-2.43.12.dist-info/top_level.txt,sha256=afAMzS9p4lcdBNxhGo6jl3ipQE9HUvvNIPOdjtPjr_Q,9
-souleyez-2.43.12.dist-info/RECORD,,
+souleyez-2.43.15.dist-info/licenses/LICENSE,sha256=J7vDD5QMF4w2oSDm35eBgosATE70ah1M40u9W4EpTZs,1090
+souleyez-2.43.15.dist-info/METADATA,sha256=5Ax1maa8aJJjBmPh5hCgS1u6HQFmxRhn9DZ3wuf0IVQ,10426
+souleyez-2.43.15.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+souleyez-2.43.15.dist-info/entry_points.txt,sha256=bN5W1dhjDZJl3TKclMjRpfQvGPmyrJLwwDuCj_X39HE,48
+souleyez-2.43.15.dist-info/top_level.txt,sha256=afAMzS9p4lcdBNxhGo6jl3ipQE9HUvvNIPOdjtPjr_Q,9
+souleyez-2.43.15.dist-info/RECORD,,