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

souleyez/engine/worker_manager.py

@@ -13,18 +13,25 @@ def is_worker_running() -> Tuple[bool, Optional[int]]:
 
     Returns: (is_running, pid)
     """
-    for proc in psutil.process_iter(['pid', 'cmdline']):
+    for proc in psutil.process_iter(["pid", "cmdline"]):
         try:
-            cmdline = proc.info.get('cmdline', [])
+            cmdline = proc.info.get("cmdline", [])
             if not cmdline:
                 continue
-            cmdline_str = ' '.join(str(arg) for arg in cmdline)
+            cmdline_str = " ".join(str(arg) for arg in cmdline)
             # Check for Python-based worker (dev mode)
-            if 'souleyez.engine.background' in cmdline_str and 'worker_loop' in cmdline_str:
-                return True, proc.info['pid']
+            if (
+                "souleyez.engine.background" in cmdline_str
+                and "worker_loop" in cmdline_str
+            ):
+                return True, proc.info["pid"]
             # Check for binary-based worker (compiled mode)
-            if 'souleyez' in cmdline_str and 'worker' in cmdline_str and 'start' in cmdline_str:
-                return True, proc.info['pid']
+            if (
+                "souleyez" in cmdline_str
+                and "worker" in cmdline_str
+                and "start" in cmdline_str
+            ):
+                return True, proc.info["pid"]
         except (psutil.NoSuchProcess, psutil.AccessDenied):
             continue
     return False, None
@@ -42,9 +49,7 @@ def is_worker_healthy() -> Tuple[bool, Optional[int], Optional[str]]:
         - pid: Worker PID if found, None otherwise
         - issue: Description of issue if not healthy, None otherwise
     """
-    from souleyez.engine.background import (
-        get_heartbeat_age, HEARTBEAT_STALE_THRESHOLD
-    )
+    from souleyez.engine.background import get_heartbeat_age, HEARTBEAT_STALE_THRESHOLD
 
     is_running, pid = is_worker_running()
 
@@ -59,7 +64,11 @@ def is_worker_healthy() -> Tuple[bool, Optional[int], Optional[str]]:
         return True, pid, "No heartbeat yet (may be starting)"
 
     if heartbeat_age > HEARTBEAT_STALE_THRESHOLD:
-        return False, pid, f"Heartbeat stale ({int(heartbeat_age)}s old, threshold: {HEARTBEAT_STALE_THRESHOLD}s)"
+        return (
+            False,
+            pid,
+            f"Heartbeat stale ({int(heartbeat_age)}s old, threshold: {HEARTBEAT_STALE_THRESHOLD}s)",
+        )
 
     return True, pid, None
 
@@ -76,6 +85,7 @@ def start_worker_if_needed() -> bool:
 
     # Start the worker
     from souleyez.engine.background import start_worker
+
     start_worker(detach=True)
     time.sleep(1)  # Give it a moment to start
 
@@ -125,19 +135,19 @@ def get_worker_status() -> dict:
     is_running, pid = is_worker_running()
 
     status = {
-        'running': is_running,
-        'pid': pid,
-        'uptime': None,
-        'cpu_percent': None,
-        'memory_mb': None
+        "running": is_running,
+        "pid": pid,
+        "uptime": None,
+        "cpu_percent": None,
+        "memory_mb": None,
     }
 
     if is_running and pid:
         try:
             proc = psutil.Process(pid)
-            status['uptime'] = int(time.time() - proc.create_time())
-            status['cpu_percent'] = proc.cpu_percent(interval=0.1)
-            status['memory_mb'] = proc.memory_info().rss / 1024 / 1024
+            status["uptime"] = int(time.time() - proc.create_time())
+            status["cpu_percent"] = proc.cpu_percent(interval=0.1)
+            status["memory_mb"] = proc.memory_info().rss / 1024 / 1024
         except (psutil.NoSuchProcess, psutil.AccessDenied):
             pass
 
@@ -159,47 +169,46 @@ def get_worker_health() -> Dict[str, Any]:
         - cpu_percent: CPU usage percentage
         - memory_mb: Memory usage in MB
     """
-    from souleyez.engine.background import (
-        get_heartbeat_age, HEARTBEAT_STALE_THRESHOLD
-    )
+    from souleyez.engine.background import get_heartbeat_age, HEARTBEAT_STALE_THRESHOLD
 
     is_running, pid = is_worker_running()
     heartbeat_age = get_heartbeat_age()
 
     health = {
-        'running': is_running,
-        'healthy': False,
-        'pid': pid,
-        'uptime': None,
-        'heartbeat_age': heartbeat_age,
-        'heartbeat_stale': heartbeat_age is None or heartbeat_age > HEARTBEAT_STALE_THRESHOLD,
-        'issue': None,
-        'cpu_percent': None,
-        'memory_mb': None
+        "running": is_running,
+        "healthy": False,
+        "pid": pid,
+        "uptime": None,
+        "heartbeat_age": heartbeat_age,
+        "heartbeat_stale": heartbeat_age is None
+        or heartbeat_age > HEARTBEAT_STALE_THRESHOLD,
+        "issue": None,
+        "cpu_percent": None,
+        "memory_mb": None,
     }
 
     if not is_running:
-        health['issue'] = "Worker process not found"
+        health["issue"] = "Worker process not found"
         return health
 
     # Get process info
     try:
         proc = psutil.Process(pid)
-        health['uptime'] = int(time.time() - proc.create_time())
-        health['cpu_percent'] = proc.cpu_percent(interval=0.1)
-        health['memory_mb'] = round(proc.memory_info().rss / 1024 / 1024, 1)
+        health["uptime"] = int(time.time() - proc.create_time())
+        health["cpu_percent"] = proc.cpu_percent(interval=0.1)
+        health["memory_mb"] = round(proc.memory_info().rss / 1024 / 1024, 1)
     except (psutil.NoSuchProcess, psutil.AccessDenied):
-        health['issue'] = "Cannot access worker process"
+        health["issue"] = "Cannot access worker process"
         return health
 
     # Check heartbeat
     if heartbeat_age is None:
-        health['issue'] = "No heartbeat yet (worker may be starting)"
-        health['healthy'] = True  # Give benefit of doubt for new workers
+        health["issue"] = "No heartbeat yet (worker may be starting)"
+        health["healthy"] = True  # Give benefit of doubt for new workers
     elif heartbeat_age > HEARTBEAT_STALE_THRESHOLD:
-        health['issue'] = f"Worker unresponsive (heartbeat {int(heartbeat_age)}s old)"
-        health['healthy'] = False
+        health["issue"] = f"Worker unresponsive (heartbeat {int(heartbeat_age)}s old)"
+        health["healthy"] = False
     else:
-        health['healthy'] = True
+        health["healthy"] = True
 
     return health

souleyez/export/evidence_bundle.py

@@ -9,62 +9,68 @@ from datetime import datetime
 from typing import Dict, List
 
 
-def create_evidence_bundle(engagement_id: int, engagement: Dict, evidence: Dict[str, List[Dict]]) -> str:
+def create_evidence_bundle(
+    engagement_id: int, engagement: Dict, evidence: Dict[str, List[Dict]]
+) -> str:
     """
     Create ZIP bundle of all evidence.
-    
+
     Returns:
         Path to created ZIP file
     """
     # Create output directory
     output_dir = os.path.expanduser("~/.souleyez/exports")
     os.makedirs(output_dir, exist_ok=True)
-    
+
     # Generate filename
     timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-    safe_name = engagement['name'].replace(' ', '_').replace('/', '_').replace('\\', '_')
+    safe_name = (
+        engagement["name"].replace(" ", "_").replace("/", "_").replace("\\", "_")
+    )
     zip_filename = f"{safe_name}_evidence_{timestamp}.zip"
     zip_path = os.path.join(output_dir, zip_filename)
-    
+
     # Create ZIP
-    with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
+    with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as zipf:
         # Add README
         readme = generate_readme(engagement, evidence)
         zipf.writestr("README.txt", readme)
-        
+
         # Add evidence by phase
         for phase, items in evidence.items():
-            phase_dir = phase.replace('_', '-')
-            
+            phase_dir = phase.replace("_", "-")
+
             # Create phase summary
             phase_summary = generate_phase_summary(phase, items)
             zipf.writestr(f"{phase_dir}/SUMMARY.txt", phase_summary)
-            
+
             for idx, item in enumerate(items, 1):
-                if item['type'] == 'job':
+                if item["type"] == "job":
                     # Add job log if exists
-                    log_path = item.get('log_path')
+                    log_path = item.get("log_path")
                     if log_path and os.path.exists(log_path):
-                        safe_tool = item['tool'].replace('/', '_')
-                        safe_target = item['target'].replace('/', '_').replace(':', '_')[:50]
+                        safe_tool = item["tool"].replace("/", "_")
+                        safe_target = (
+                            item["target"].replace("/", "_").replace(":", "_")[:50]
+                        )
                         arcname = f"{phase_dir}/{idx:03d}_{safe_tool}_{safe_target}.log"
                         zipf.write(log_path, arcname)
-        
+
         # Add credentials file
         creds_content = export_credentials(engagement_id)
         if creds_content:
             zipf.writestr("CREDENTIALS.txt", creds_content)
-        
+
         # Add findings file
         findings_content = export_findings(engagement_id)
         if findings_content:
             zipf.writestr("FINDINGS.txt", findings_content)
-        
+
         # Add hosts summary
         hosts_content = export_hosts(engagement_id)
         if hosts_content:
             zipf.writestr("HOSTS.txt", hosts_content)
-    
+
     return zip_path
 
 
@@ -77,18 +83,18 @@ def generate_readme(engagement: Dict, evidence: Dict[str, List[Dict]]) -> str:
     lines.append(f"Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
     lines.append(f"Engagement ID: {engagement['id']}")
     lines.append("")
-    
+
     # Summary
     total = sum(len(items) for items in evidence.values())
     lines.append(f"Total Evidence Items: {total}")
     lines.append("")
-    
+
     lines.append("Evidence by Phase:")
     lines.append("-" * 70)
     for phase, items in evidence.items():
-        phase_name = phase.replace('_', ' ').title()
+        phase_name = phase.replace("_", " ").title()
         lines.append(f"  {phase_name:30} {len(items):3} items")
-    
+
     lines.append("")
     lines.append("=" * 70)
     lines.append("")
@@ -131,151 +137,155 @@ def generate_readme(engagement: Dict, evidence: Dict[str, List[Dict]]) -> str:
     lines.append("- Timestamps are in UTC")
     lines.append("- Sensitive data (passwords) may be redacted")
     lines.append("")
-    
+
     return "\n".join(lines)
 
 
 def generate_phase_summary(phase: str, items: List[Dict]) -> str:
     """Generate summary for a phase."""
     lines = []
-    phase_name = phase.replace('_', ' ').upper()
-    
+    phase_name = phase.replace("_", " ").upper()
+
     lines.append("=" * 70)
     lines.append(f"{phase_name} - EVIDENCE SUMMARY")
     lines.append("=" * 70)
     lines.append("")
     lines.append(f"Total Items: {len(items)}")
     lines.append("")
-    
+
     for idx, item in enumerate(items, 1):
         lines.append(f"[{idx:03d}] {item['title']}")
         lines.append(f"      Tool: {item['tool']}")
         lines.append(f"      Target: {item['target']}")
         lines.append(f"      Date: {item['created_at']}")
         lines.append(f"      Description: {item['description']}")
-        
-        if item['type'] == 'finding':
+
+        if item["type"] == "finding":
             lines.append(f"      Severity: {item['severity'].upper()}")
-        elif item['type'] == 'credential':
+        elif item["type"] == "credential":
             lines.append(f"      Type: Credential Discovery")
-        
+
         lines.append("")
-    
+
     return "\n".join(lines)
 
 
 def export_credentials(engagement_id: int) -> str:
     """Export credentials as text."""
     from souleyez.storage.credentials import CredentialsManager
-    
+
     cm = CredentialsManager()
     creds = cm.list_credentials(engagement_id)
-    
+
     if not creds:
         return ""
-    
+
     lines = []
     lines.append("=" * 70)
     lines.append("CREDENTIALS DISCOVERED")
     lines.append("=" * 70)
     lines.append(f"Total: {len(creds)} credentials")
     lines.append("")
-    
+
     for idx, cred in enumerate(creds, 1):
-        lines.append(f"[{idx:03d}] Host: {cred.get('host', 'N/A')}:{cred.get('port', '?')}")
+        lines.append(
+            f"[{idx:03d}] Host: {cred.get('host', 'N/A')}:{cred.get('port', '?')}"
+        )
         lines.append(f"      Service: {cred.get('service', 'unknown')}")
         lines.append(f"      Username: {cred.get('username', 'N/A')}")
         lines.append(f"      Status: {cred.get('status', 'unknown')}")
         lines.append(f"      Source: {cred.get('source', 'unknown')}")
         lines.append(f"      Created: {cred.get('created_at', 'N/A')}")
         lines.append("-" * 70)
-    
+
     return "\n".join(lines)
 
 
 def export_findings(engagement_id: int) -> str:
     """Export findings as text."""
     from souleyez.storage.findings import FindingsManager
-    
+
     fm = FindingsManager()
     findings = fm.list_findings(engagement_id)
-    
+
     if not findings:
         return ""
-    
+
     lines = []
     lines.append("=" * 70)
     lines.append("SECURITY FINDINGS")
     lines.append("=" * 70)
     lines.append(f"Total: {len(findings)} findings")
     lines.append("")
-    
+
     # Group by severity
     by_severity = {}
     for finding in findings:
-        sev = finding.get('severity', 'info')
+        sev = finding.get("severity", "info")
         if sev not in by_severity:
             by_severity[sev] = []
         by_severity[sev].append(finding)
-    
-    for severity in ['critical', 'high', 'medium', 'low', 'info']:
+
+    for severity in ["critical", "high", "medium", "low", "info"]:
         sev_findings = by_severity.get(severity, [])
         if sev_findings:
             lines.append(f"\n{severity.upper()}: {len(sev_findings)} findings")
             lines.append("-" * 70)
-            
+
             for finding in sev_findings:
                 lines.append(f"\nTitle: {finding['title']}")
                 lines.append(f"Tool: {finding.get('tool', 'Unknown')}")
-                target = finding.get('host') or finding.get('url', 'Unknown')
+                target = finding.get("host") or finding.get("url", "Unknown")
                 lines.append(f"Target: {target}")
-                
-                if finding.get('cve'):
+
+                if finding.get("cve"):
                     lines.append(f"CVE: {finding['cve']}")
-                if finding.get('cvss'):
+                if finding.get("cvss"):
                     lines.append(f"CVSS: {finding['cvss']}")
-                
-                desc = finding.get('description', '')
+
+                desc = finding.get("description", "")
                 if desc:
                     lines.append(f"Description: {desc[:500]}")
-                
+
                 lines.append("")
-    
+
     return "\n".join(lines)
 
 
 def export_hosts(engagement_id: int) -> str:
     """Export hosts summary."""
     from souleyez.storage.hosts import HostManager
-    
+
     hm = HostManager()
     hosts = hm.list_hosts(engagement_id)
-    
+
     if not hosts:
         return ""
-    
+
     lines = []
     lines.append("=" * 70)
     lines.append("DISCOVERED HOSTS")
     lines.append("=" * 70)
     lines.append(f"Total: {len(hosts)} hosts")
     lines.append("")
-    
+
     for host in hosts:
         lines.append(f"Host: {host.get('ip', 'N/A')}")
         lines.append(f"  Hostname: {host.get('hostname', 'N/A')}")
         lines.append(f"  Status: {host.get('status', 'unknown')}")
         lines.append(f"  OS: {host.get('os', 'Unknown')}")
-        
+
         # Get services count
-        services = host.get('services', [])
+        services = host.get("services", [])
         if services:
             lines.append(f"  Services: {len(services)}")
             for svc in services[:5]:  # First 5 services
-                lines.append(f"    - {svc.get('port', '?')}/{svc.get('protocol', 'tcp')}: {svc.get('service', 'unknown')}")
+                lines.append(
+                    f"    - {svc.get('port', '?')}/{svc.get('protocol', 'tcp')}: {svc.get('service', 'unknown')}"
+                )
             if len(services) > 5:
                 lines.append(f"    (and {len(services) - 5} more...)")
-        
+
         lines.append("")
-    
+
     return "\n".join(lines)

souleyez/feature_flags/features.py

@@ -11,11 +11,12 @@ from typing import Dict, Optional
 
 class FeatureStatus(Enum):
     """Status of a feature."""
-    ENABLED = "enabled"          # Feature is fully implemented and available
-    DISABLED = "disabled"        # Feature is hidden from users
-    BETA = "beta"               # Feature is available but marked as beta
-    DEVELOPMENT = "development" # Feature is under development (hidden in production)
-    PRO = "pro"                 # Feature requires Pro tier
+
+    ENABLED = "enabled"  # Feature is fully implemented and available
+    DISABLED = "disabled"  # Feature is hidden from users
+    BETA = "beta"  # Feature is available but marked as beta
+    DEVELOPMENT = "development"  # Feature is under development (hidden in production)
+    PRO = "pro"  # Feature requires Pro tier
 
 
 class Feature(Enum):
@@ -62,28 +63,23 @@ class FeatureFlags:
         # Export Features - Placeholder implementations
         Feature.JSON_EXPORT: FeatureStatus.DISABLED,
         Feature.HOSTS_SERVICES_EXPORT: FeatureStatus.DISABLED,
-
         # Import Features - Placeholder implementations
         Feature.NMAP_XML_IMPORT: FeatureStatus.DISABLED,
         Feature.NESSUS_IMPORT: FeatureStatus.DISABLED,
-
         # Analysis Features
-        Feature.EVIDENCE_LINKING: FeatureStatus.ENABLED,      # FREE - basic feature
-        Feature.CORRELATION_ENGINE: FeatureStatus.PRO,        # PRO - advanced analysis
-        Feature.ATTACK_SURFACE: FeatureStatus.PRO,            # PRO - priority scoring
-        Feature.EXPLOIT_SUGGESTIONS: FeatureStatus.PRO,       # PRO - CVE/MSF recommendations
-
+        Feature.EVIDENCE_LINKING: FeatureStatus.ENABLED,  # FREE - basic feature
+        Feature.CORRELATION_ENGINE: FeatureStatus.PRO,  # PRO - advanced analysis
+        Feature.ATTACK_SURFACE: FeatureStatus.PRO,  # PRO - priority scoring
+        Feature.EXPLOIT_SUGGESTIONS: FeatureStatus.PRO,  # PRO - CVE/MSF recommendations
         # Dashboard Features
-        Feature.TEAM_DASHBOARD: FeatureStatus.PRO,            # PRO - collaboration
-        Feature.TIMELINE_VIEW: FeatureStatus.ENABLED,         # FREE - basic timeline
-
+        Feature.TEAM_DASHBOARD: FeatureStatus.PRO,  # PRO - collaboration
+        Feature.TIMELINE_VIEW: FeatureStatus.ENABLED,  # FREE - basic timeline
         # Reporting Features
-        Feature.DELIVERABLES: FeatureStatus.ENABLED,          # FREE - basic tracking
-        Feature.EXPORT_VIEW: FeatureStatus.PRO,               # PRO - report export
-
+        Feature.DELIVERABLES: FeatureStatus.ENABLED,  # FREE - basic tracking
+        Feature.EXPORT_VIEW: FeatureStatus.PRO,  # PRO - report export
         # Advanced Features
-        Feature.AUTO_CHAINING: FeatureStatus.PRO,             # PRO - automation
-        Feature.AI_RECOMMENDATIONS: FeatureStatus.PRO,        # PRO - AI features
+        Feature.AUTO_CHAINING: FeatureStatus.PRO,  # PRO - automation
+        Feature.AI_RECOMMENDATIONS: FeatureStatus.PRO,  # PRO - AI features
     }
 
     @classmethod

souleyez/feature_flags.py

@@ -11,10 +11,11 @@ from typing import Dict, Optional
 
 class FeatureStatus(Enum):
     """Status of a feature."""
-    ENABLED = "enabled"          # Feature is fully implemented and available
-    DISABLED = "disabled"        # Feature is hidden from users
-    BETA = "beta"               # Feature is available but marked as beta
-    DEVELOPMENT = "development" # Feature is under development (hidden in production)
+
+    ENABLED = "enabled"  # Feature is fully implemented and available
+    DISABLED = "disabled"  # Feature is hidden from users
+    BETA = "beta"  # Feature is available but marked as beta
+    DEVELOPMENT = "development"  # Feature is under development (hidden in production)
 
 
 class Feature(Enum):
@@ -61,25 +62,20 @@ class FeatureFlags:
         # Export Features - Placeholder implementations
         Feature.JSON_EXPORT: FeatureStatus.DISABLED,
         Feature.HOSTS_SERVICES_EXPORT: FeatureStatus.DISABLED,
-
         # Import Features - Placeholder implementations
         Feature.NMAP_XML_IMPORT: FeatureStatus.DISABLED,
         Feature.NESSUS_IMPORT: FeatureStatus.DISABLED,
-
         # Analysis Features - Implemented
         Feature.EVIDENCE_LINKING: FeatureStatus.ENABLED,
         Feature.CORRELATION_ENGINE: FeatureStatus.ENABLED,
         Feature.ATTACK_SURFACE: FeatureStatus.ENABLED,
         Feature.EXPLOIT_SUGGESTIONS: FeatureStatus.ENABLED,
-
         # Dashboard Features - Implemented
         Feature.TEAM_DASHBOARD: FeatureStatus.ENABLED,
         Feature.TIMELINE_VIEW: FeatureStatus.ENABLED,
-
         # Reporting Features - Implemented
         Feature.DELIVERABLES: FeatureStatus.ENABLED,
         Feature.EXPORT_VIEW: FeatureStatus.ENABLED,
-
         # Advanced Features
         Feature.AUTO_CHAINING: FeatureStatus.ENABLED,
         Feature.AI_RECOMMENDATIONS: FeatureStatus.ENABLED,

souleyez/handlers/__init__.py

@@ -0,0 +1,11 @@
+#!/usr/bin/env python3
+"""
+Tool handlers package.
+
+Each tool has a handler class that consolidates:
+- Parsing logic (from result_handler.py)
+- Display logic (from interactive.py)
+- Capability flags (replaces manual lists)
+
+Auto-discovery: Handlers are registered automatically when imported.
+"""