exploitDF.py

"""
ExploitDF - Command-line penetration testing framework

"""

import sys
import os
import argparse
import subprocess
import json
import csv
import time
import threading
from pathlib import Path
import importlib.util
from datetime import datetime
import re
import glob
import threading
import queue
from BaseModule import BaseModule, ScannerModule

try:
    import readline   # for Linux/macOS
except ImportError:
    import pyreadline3 as readline   # for Windows
if not hasattr(readline, "backend"):
    readline.backend = "pyreadline"

class ExploitDF:
    def __init__(self):
        self.version = "1.0.0"
        self.banner_text = f"""
    ______           __      _ __   ____  ______
   / ____/  ______  / /___  (_) /_ / __ \\/ ____/
  / __/ | |/_/ __ \\/ / __ \\/ / __// / / / /_
 / /____>  </ /_/ / / /_/ / / /_ / /_/ / __/
/_____/_/|_/ .___/_/\\____/_/\\__//_____/_/
          /_/

ExploitDF Framework v{self.version}
Developed by Defronix
Type 'help' for available commands
"""

        # Framework state
        self.current_module = None
        self.global_variables = {}
        self.session_variables = {}
        self.modules = {}
        self.jobs = {}
        self.history = []
        self.debug_mode = False
        self.spool_file = None
        self.module_stack = []
        self.favorites = []
        self.sessions = {}
        self.background_threads = []
        self.features = ['core', 'modules', 'jobs', 'sessions', 'threading']
        self.loadpaths = ['modules/']
        self.workspace = 'default'
        self.notes_db = {}

        # Command categories
        self.core_commands = {
            '?': self.do_help,
            'banner': self.do_banner,
            'cd': self.do_cd,
            'connect': self.do_connect,
            'debug': self.do_debug,
            'exit': self.do_exit,
            'features': self.do_features,
            'get': self.do_get,
            'getg': self.do_getg,
            'grep': self.do_grep,
            'help': self.do_help,
            'history': self.do_history,
            'load': self.do_load,
            'quit': self.do_exit,
            'repeat': self.do_repeat,
            'route': self.do_route,
            'save': self.do_save,
            'sessions': self.do_sessions,
            'set': self.do_set,
            'setg': self.do_setg,
            'sleep': self.do_sleep,
            'spool': self.do_spool,
            'threads': self.do_threads,
            'tips': self.do_tips,
            'unload': self.do_unload,
            'update': self.do_update,
            'unset': self.do_unset,
            'unsetg': self.do_unsetg,
            'version': self.do_version,
            'clear': self.do_clear,
            'notes': self.do_notes
        }

        self.module_commands = {
            'advanced': self.do_advanced,
            'back': self.do_back,
            'clearm': self.do_clearm,
            'favorite': self.do_favorite,
            'favorites': self.do_favorites,
            'info': self.do_info,
            'listm': self.do_listm,
            'loadpath': self.do_loadpath,
            'options': self.do_options,
            'popm': self.do_popm,
            'previous': self.do_previous,
            'pushm': self.do_pushm,
            'reload_all': self.do_reload_all,
            'search': self.do_search,
            'show': self.do_show,
            'use': self.do_use,
            'run': self.do_run
        }

        self.job_commands = {
            'handler': self.do_handler,
            'jobs': self.do_jobs,
            'kill': self.do_kill,
            'rename_job': self.do_rename_job
        }

        self.dns_commands = {
            'dns': self.do_dns
        }

        # Combine all commands
        self.all_commands = {**self.core_commands, **self.module_commands,
                           **self.job_commands, **self.dns_commands}

        # Command descriptions for help
        self.command_descriptions = {
            '?': 'Display help information',
            'banner': 'Display the ExploitDF banner',
            'cd': 'Change the current working directory',
            'connect': 'Communicate with a host',
            'debug': 'Toggle debug mode',
            'exit': 'Exit the framework',
            'features': 'Display the list of enabled features',
            'get': 'Gets the value of a context-specific variable',
            'getg': 'Gets the value of a global variable',
            'grep': 'Grep the output of another command',
            'help': 'Display help information',
            'history': 'Show command history',
            'load': 'Load a framework plugin',
            'quit': 'Exit the framework',
            'repeat': 'Repeat a list of commands',
            'route': 'Route traffic through a session',
            'save': 'Save the active datastores',
            'sessions': 'Dump session listings and display information',
            'set': 'Set a context-specific variable to a value',
            'setg': 'Set a global variable to a value',
            'sleep': 'Do nothing for the specified number of seconds',
            'spool': 'Write console output into a file as well as the screen',
            'threads': 'View and manipulate background threads',
            'tips': 'Show a list of useful productivity tips',
            'unload': 'Unload a framework plugin',
            'update': 'Update the framework from the Git repository',
            'unset': 'Unset one or more context-specific variables',
            'unsetg': 'Unset one or more global variables',
            'version': 'Show the framework and console library version numbers',
            'clear': 'Clear the console screen',
            'notes': 'Manage notes for hosts and modules',
            'advanced': 'Display all advanced options',
            'back': 'Move back from current context',
            'clearm': 'Clear the module stack',
            'favorite': 'Add a module to favorites',
            'favorites': 'Print the list of favorite modules',
            'info': 'Display information about one or more modules',
            'listm': 'List all modules in the database',
            'loadpath': 'Search for and load modules from a path',
            'options': 'Display global options or for one or more modules',
            'popm': 'Pop the latest module off of the module stack',
            'previous': 'Set the previously loaded module as the current module',
            'pushm': 'Push the active or list of modules onto the module stack',
            'reload_all': 'Reload all modules from all defined module paths',
            'search': 'Search for modules',
            'show': 'Display modules of a given type, or all modules',
            'use': 'Select a module by name',
            'run': 'Launch the currently selected module',
            'handler': 'Start a payload handler as a job',
            'jobs': 'Display and manage jobs',
            'kill': 'Kill a job',
            'rename_job': 'Rename a job',
            'dns': 'Manage the DNS resolver'
        }

        # Load all modules
        self.load_modules()

    def load_modules(self):
        """Load auxiliary modules from modules directory"""
        # Get the directory where the current script is located
        current_script_dir = Path(__file__).parent
        modules_dir = current_script_dir / "modules"

        if modules_dir.exists():
            for module_path in modules_dir.rglob("*.py"):
                if module_path.name != "__init__.py":
                    try:
                        spec = importlib.util.spec_from_file_location(
                            module_path.stem, module_path
                        )
                        module = importlib.util.module_from_spec(spec)
                        spec.loader.exec_module(module)

                        # Look for module classes
                        for attr_name in dir(module):
                            attr = getattr(module, attr_name)
                            if (isinstance(attr, type) and
                                issubclass(attr, BaseModule) and
                                attr != BaseModule):
                                module_name = str(module_path.relative_to(modules_dir)).replace(".py", "").replace("\\", "/")
                                self.modules[module_name] = attr
                    except Exception as e:
                        if self.debug_mode:
                            print(f"Error loading module {module_path}: {e}")

    def get_prompt(self):
        """Get the current command prompt"""
        if self.current_module:
            return f"exploitdf {self.current_module.info['name']} > "
        return "exploitdf > "

    def run(self):
        """Main command loop"""
        print(self.banner_text)

        while True:
            try:
                prompt = self.get_prompt()
                line = input(prompt).strip()

                if not line:
                    continue

                # Add to history
                self.history.append(line)

                # Parse and execute command
                self.execute_command(line)

            except (EOFError, KeyboardInterrupt):
                print("\nExiting...")
                break
            except Exception as e:
                if self.debug_mode:
                    print(f"Error: {e}")
                else:
                    print("An error occurred. Enable debug mode for details.")

    def execute_command(self, line):
        """Execute a command line"""
        parts = line.split()
        if not parts:
            return

        command = parts[0].lower()
        args = parts[1:]

        if command in self.all_commands:
            try:
                self.all_commands[command](args)
            except Exception as e:
                if self.debug_mode:
                    print(f"Command error: {e}")
                else:
                    print(f"Error executing command: {command}")
        else:
            print(f"Unknown command: {command}")

    # Core Commands Implementation
    def do_help(self, args):
        """Display help information"""
        if not args:
            print("\nCore Commands")
            print("=============")
            for do in sorted(self.core_commands.keys()):
                print(f"    {do:<12} {self.command_descriptions.get(do, '')}")

            print("\nModule Commands")
            print("===============")
            for do in sorted(self.module_commands.keys()):
                print(f"    {do:<12} {self.command_descriptions.get(do, '')}")

            print("\nJob Commands")
            print("============")
            for do in sorted(self.job_commands.keys()):
                print(f"    {do:<12} {self.command_descriptions.get(do, '')}")

            print("\nDNS Commands")
            print("============")
            for do in sorted(self.dns_commands.keys()):
                print(f"    {do:<12} {self.command_descriptions.get(do, '')}")
        else:
            command = args[0].lower()
            if command == "notes":
                self.show_notes_help()
            elif command in self.command_descriptions:
                print(f"\n{command}: {self.command_descriptions[command]}")
            else:
                print(f"No help available for: {command}")

    def show_notes_help(self):
        """Show detailed help for notes command"""
        help_text = """
Usage: notes [-h] [-t <type1,type2>] [-n <data string>] [-a] [addr range]

OPTIONS:
    -a, --add                 Add a note to the list of addresses.
    -d, --delete              Delete notes instead of searching.
    -h, --help                Show this help information.
    -n, --note <note>         Set the data for a new note (only with -a).
    -O, --order <column id>   Order rows by specified column number.
    -o, --output <filename>   Save the notes to a CSV file.
    -R, --rhosts              Set RHOSTS from search results.
    -S, --search <filter>     Search string to filter by.
    -t, --type <type1,type2>  Search by type, or set type for add.
    -u, --update              Update a note (experimental).

Examples:
  notes --add -t apps -n 'winzip' 10.1.1.34 10.1.20.41
  notes -t smb.fingerprint 10.1.1.34 10.1.20.41
  notes -S 'nmap.nse.(http|rtsp)'
"""
        print(help_text)

    def do_banner(self, args):
        """Display the ExploitDF banner"""
        print(self.banner_text)

    def do_update(self, args):
        """Checks for and applies updates from the Git repository."""
        print("[*] Checking for updates...")
        
        try:
            # Command to discard local changes and pull the latest version
            command = "git checkout . && git pull"
            
            # Execute the command
            process = subprocess.Popen(
                command,
                shell=True,
                stdout=subprocess.PIPE,
                stderr=subprocess.STDOUT
            )
            
            # Read the output
            output, _ = process.communicate()
            output = output.decode('utf-8', errors='ignore')

            # Analyze the output to determine the result
            if "Already up to date" in output:
                print("[+] ExploitDF is already the latest version.")
            elif "Updating" in output or "Fast-forward" in output:
                print("[+] Update in progress...")
                print(output) # Show the git output
                print("\n[+] ExploitDF has been updated successfully!")
                print("[*] Restarting to apply updates...")
                
                # Restart the script
                os.execv(sys.executable, [sys.executable] + sys.argv)
            elif "not a git repository" in output:
                self.print_error("This is not a Git repository. Cannot update.")
                self.print_warning("Please install using 'git clone' to enable updates.")
            else:
                self.print_error("An unknown error occurred during the update.")
                print("\n--- Git Output ---")
                print(output)
                print("------------------")

        except FileNotFoundError:
            self.print_error("'git' command not found.")
            self.print_warning("Please install Git to use the update feature.")
        except Exception as e:
            self.print_error(f"An exception occurred: {e}")


    def do_version(self, args):
        """Show version information"""
        print(f"Framework: ExploitDF {self.version}")
        print(f"Console: Python {sys.version}")

    def do_exit(self, args):
        """Exit the framework"""
        print("Goodbye!")
        sys.exit(0)

    def do_clear(self, args):
        """Clear the console screen"""
        os.system('cls' if os.name == 'nt' else 'clear')

    def do_debug(self, args):
        """Toggle debug mode"""
        self.debug_mode = not self.debug_mode
        print(f"Debug mode: {'enabled' if self.debug_mode else 'disabled'}")

    def do_set(self, args):
        """Set a context-specific variable"""
        if len(args) < 2:
            print("Usage: set <variable> <value>")
            return

        var_name = args[0]
        var_value = ' '.join(args[1:])

        if self.current_module:
            self.current_module.set_option(var_name, var_value)
            print(f"{var_name} => {var_value}")
        else:
            self.session_variables[var_name] = var_value
            print(f"{var_name} => {var_value}")

    def do_setg(self, args):
        """Set a global variable"""
        if len(args) < 2:
            print("Usage: setg <variable> <value>")
            return

        var_name = args[0]
        var_value = ' '.join(args[1:])
        self.global_variables[var_name] = var_value
        print(f"{var_name} => {var_value}")

    def do_get(self, args):
        """Get a context-specific variable"""
        if not args:
            if self.current_module:
                for key, value in self.current_module.options.items():
                    print(f"{key} = {value}")
            else:
                for key, value in self.session_variables.items():
                    print(f"{key} = {value}")
        else:
            var_name = args[0]
            if self.current_module and var_name in self.current_module.options:
                print(f"{var_name} = {self.current_module.options[var_name]}")
            elif var_name in self.session_variables:
                print(f"{var_name} = {self.session_variables[var_name]}")
            else:
                print(f"Variable {var_name} not found")

    def do_getg(self, args):
        """Get a global variable"""
        if not args:
            for key, value in self.global_variables.items():
                print(f"{key} = {value}")
        else:
            var_name = args[0]
            if var_name in self.global_variables:
                print(f"{var_name} = {self.global_variables[var_name]}")
            else:
                print(f"Global variable {var_name} not found")

    def do_unset(self, args):
        """Unset context-specific variables"""
        for var_name in args:
            if self.current_module and var_name in self.current_module.options:
                del self.current_module.options[var_name]
                print(f"Unset {var_name}")
            elif var_name in self.session_variables:
                del self.session_variables[var_name]
                print(f"Unset {var_name}")

    def do_unsetg(self, args):
        """Unset global variables"""
        for var_name in args:
            if var_name in self.global_variables:
                del self.global_variables[var_name]
                print(f"Unset global {var_name}")

    def do_use(self, args):
        """Select a module by name"""
        if not args:
            print("Usage: use <module_name>")
            return

        module_name = args[0]
        if module_name in self.modules:
            self.current_module = self.modules[module_name]()
            print(f"Using module: {module_name}")
        else:
            print(f"Module not found: {module_name}")

    def do_back(self, args):
        """Move back from current context"""
        if self.current_module:
            print(f"Leaving module: {self.current_module.info['name']}")
            self.current_module = None
        else:
            print("Already at top level")

    def do_info(self, args):
        """Display information about current or specified module"""
        if self.current_module:
            self.current_module.show_info()
        elif args and args[0] in self.modules:
            module = self.modules[args[0]]()
            module.show_info()
        else:
            print("No module selected or specified")

    def do_options(self, args):
        """Display options for current module"""
        if self.current_module:
            self.current_module.show_options()
        else:
            print("No module selected")

    def do_run(self, args):
        """Run the current module"""
        if self.current_module:
            self.current_module.run()
        else:
            print("No module selected")

    def do_show(self, args):
        """Show modules"""
        if not args:
            print("\nAuxiliary modules:")
            for name, module_class in self.modules.items():
                if "auxiliary" in name:
                    module_info = module_class().info
                    print(f"  {name:<30} {module_info.get('description', '')}")


            print("\nScanner modules:")
            for name, module_class in self.modules.items():
                if "scanners" in name:
                    module_info = module_class().info
                    print(f"  {name:<30} {module_info.get('description', '')}")

        else:
            show_type = args[0].lower()
            if show_type == "auxiliary":
                print("\nAuxiliary modules:")
                for name, module_class in self.modules.items():
                    if "auxiliary" in name:
                        module_info = module_class().info
                        print(f"  {name:<30} {module_info.get('description', '')}")
            elif show_type == "scanners":
                print("\nScanner modules:")
                for name, module_class in self.modules.items():
                    if "scanners" in name:
                        module_info = module_class().info
                        print(f"  {name:<30} {module_info.get('description', '')}")


    def do_search(self, args):
        """Search for modules"""
        if not args:
            print("Usage: search <term>")
            return

        search_term = args[0].lower()
        print(f"\nMatching modules for '{search_term}':")

        for name, module_class in self.modules.items():
            module_info = module_class().info
            if (search_term in name.lower() or
                search_term in module_info.get('description', '').lower() or
                search_term in module_info.get('author', '').lower()):
                print(f"  {name:<30} {module_info.get('description', '')}")

    def do_notes(self, args):
        """Manage notes command with full flag support"""
        parser = argparse.ArgumentParser(prog='notes', add_help=False)
        parser.add_argument('-a', '--add', action='store_true', help='Add a note')
        parser.add_argument('-d', '--delete', action='store_true', help='Delete notes')
        parser.add_argument('-h', '--help', action='store_true', help='Show help')
        parser.add_argument('-n', '--note', help='Note content')
        parser.add_argument('-t', '--type', help='Note type')
        parser.add_argument('-o', '--output', help='Output file')
        parser.add_argument('-S', '--search', help='Search filter')
        parser.add_argument('addresses', nargs='*', help='IP addresses')

        try:
            parsed_args = parser.parse_args(args)

            if parsed_args.help:
                self.show_notes_help()
                return

            if parsed_args.add:
                note_type = parsed_args.type or "general"
                note_content = parsed_args.note or "No content"
                addresses = parsed_args.addresses or []
                print(f"Adding note: type={note_type}, content={note_content}, addresses={addresses}")
            elif parsed_args.search:
                print(f"Searching notes with filter: {parsed_args.search}")
            else:
                print("Current notes: (empty)")

        except SystemExit:
            pass
        except Exception as e:
            print(f"Notes command error: {e}")

    # Placeholder implementations for other commands
    def do_cd(self, args):
        if args:
            try:
                os.chdir(args[0])
                print(f"Changed directory to: {os.getcwd()}")
            except FileNotFoundError:
                print(f"Directory not found: {args[0]}")
        else:
            print(f"Current directory: {os.getcwd()}")

    def do_connect(self, args):
        """Connect to a host with flags support"""
        parser = argparse.ArgumentParser(prog='connect', add_help=False)
        parser.add_argument('-h', '--help', action='store_true', help='Show help')
        parser.add_argument('-p', '--port', type=int, default=23, help='Port to connect to')
        parser.add_argument('-s', '--ssl', action='store_true', help='Use SSL/TLS')
        parser.add_argument('-t', '--timeout', type=int, default=10, help='Connection timeout')
        parser.add_argument('host', nargs='?', help='Target host')

        try:
            parsed_args = parser.parse_args(args)

            if parsed_args.help:
                print("""Usage: connect [-h] [-p <port>] [-s] [-t <timeout>] <host>

OPTIONS:
    -h, --help                Show this help information.
    -p, --port <port>         Port to connect to (default: 23).
    -s, --ssl                 Use SSL/TLS connection.
    -t, --timeout <timeout>   Connection timeout in seconds (default: 10).

Examples:
  connect 192.168.1.1
  connect -p 443 -s example.com
  connect -p 22 -t 5 target.local""")
                return

            if not parsed_args.host:
                print("Error: Host is required")
                return

            print(f"Connecting to {parsed_args.host}:{parsed_args.port}")
            print(f"SSL: {'enabled' if parsed_args.ssl else 'disabled'}")
            print(f"Timeout: {parsed_args.timeout}s")
            print("Connect functionality - basic implementation")

        except SystemExit:
            pass
        except Exception as e:
            print(f"Connect command error: {e}")

    def do_features(self, args):
        """Display enabled features with flags support"""
        parser = argparse.ArgumentParser(prog='features', add_help=False)
        parser.add_argument('-h', '--help', action='store_true', help='Show help')
        parser.add_argument('-l', '--list', action='store_true', help='List all features')
        parser.add_argument('-v', '--verbose', action='store_true', help='Verbose output')

        try:
            parsed_args = parser.parse_args(args)

            if parsed_args.help:
                print("""Usage: features [-h] [-l] [-v]

OPTIONS:
    -h, --help      Show this help information.
    -l, --list      List all available features.
    -v, --verbose   Show detailed feature information.

Examples:
  features
  features -l
  features -v""")
                return

            print("Enabled features:")
            for feature in self.features:
                if parsed_args.verbose:
                    descriptions = {
                        'core': 'Core framework functionality',
                        'modules': 'Module loading and management',
                        'jobs': 'Background job management',
                        'sessions': 'Session handling',
                        'threading': 'Multi-threaded operations'
                    }
                    desc = descriptions.get(feature, 'No description')
                    print(f"  {feature:<12} - {desc}")
                else:
                    print(f"  {feature}")

        except SystemExit:
            pass
        except Exception as e:
            print(f"Features command error: {e}")

    def do_grep(self, args):
        """Grep command output with flags support"""
        parser = argparse.ArgumentParser(prog='grep', add_help=False)
        parser.add_argument('-h', '--help', action='store_true', help='Show help')
        parser.add_argument('-i', '--ignore-case', action='store_true', help='Ignore case')
        parser.add_argument('-v', '--invert', action='store_true', help='Invert match')
        parser.add_argument('-c', '--count', action='store_true', help='Count matches')
        parser.add_argument('pattern', nargs='?', help='Search pattern')
        parser.add_argument('command', nargs='*', help='Command to grep')

        try:
            parsed_args = parser.parse_args(args)

            if parsed_args.help:
                print("""Usage: grep [-h] [-i] [-v] [-c] <pattern> <command>

OPTIONS:
    -h, --help         Show this help information.
    -i, --ignore-case  Ignore case distinctions.
    -v, --invert       Invert the sense of matching.
    -c, --count        Print count of matching lines.

Examples:
  grep -i "http" show auxiliary
  grep -v "scanner" search port
  grep -c "module" listm""")
                return

            if not parsed_args.pattern:
                print("Error: Pattern is required")
                return

            print(f"Grep pattern: {parsed_args.pattern}")
            print("Grep functionality - basic implementation")

        except SystemExit:
            pass
        except Exception as e:
            print(f"Grep command error: {e}")

    def do_history(self, args):
        """Show command history with flags support"""
        parser = argparse.ArgumentParser(prog='history', add_help=False)
        parser.add_argument('-h', '--help', action='store_true', help='Show help')
        parser.add_argument('-c', '--clear', action='store_true', help='Clear history')
        parser.add_argument('-n', '--number', type=int, default=10, help='Number of entries')
        parser.add_argument('-s', '--save', help='Save history to file')

        try:
            parsed_args = parser.parse_args(args)

            if parsed_args.help:
                print("""Usage: history [-h] [-c] [-n <number>] [-s <file>]

OPTIONS:
    -h, --help           Show this help information.
    -c, --clear          Clear command history.
    -n, --number <num>   Show last N commands (default: 10).
    -s, --save <file>    Save history to file.

Examples:
  history
  history -n 20
  history -s /tmp/history.txt
  history -c""")
                return

            if parsed_args.clear:
                self.history.clear()
                print("History cleared")
                return

            if parsed_args.save:
                try:
                    with open(parsed_args.save, 'w') as f:
                        for do in self.history:
                            f.write(f"{do}\n")
                    print(f"History saved to {parsed_args.save}")
                except Exception as e:
                    print(f"Error saving history: {e}")
                return

            recent_history = self.history[-parsed_args.number:]
            for i, do in enumerate(recent_history, 1):
                print(f"{i:3}: {do}")

        except SystemExit:
            pass
        except Exception as e:
            print(f"History command error: {e}")

    def do_load(self, args):
        """Load framework plugins with flags support"""
        parser = argparse.ArgumentParser(prog='load', add_help=False)
        parser.add_argument('-h', '--help', action='store_true', help='Show help')
        parser.add_argument('-f', '--force', action='store_true', help='Force reload')
        parser.add_argument('-v', '--verbose', action='store_true', help='Verbose output')
        parser.add_argument('plugin', nargs='?', help='Plugin name to load')

        try:
            parsed_args = parser.parse_args(args)

            if parsed_args.help:
                print("""Usage: load [-h] [-f] [-v] <plugin>

OPTIONS:
    -h, --help      Show this help information.
    -f, --force     Force reload if already loaded.
    -v, --verbose   Show detailed loading information.

Examples:
  load db_sqlite
  load -f -v custom_plugin
  load scanner_engine""")
                return

            if not parsed_args.plugin:
                print("Available plugins: db_sqlite, scanner_engine, custom_modules")
                return

            print(f"Loading plugin: {parsed_args.plugin}")
            if parsed_args.verbose:
                print(f"Force reload: {parsed_args.force}")
            print("Load functionality - basic implementation")

        except SystemExit:
            pass
        except Exception as e:
            print(f"Load command error: {e}")

    def do_repeat(self, args):
        """Repeat commands with flags support"""
        parser = argparse.ArgumentParser(prog='repeat', add_help=False)
        parser.add_argument('-h', '--help', action='store_true', help='Show help')
        parser.add_argument('-t', '--times', type=int, default=1, help='Number of times')
        parser.add_argument('-d', '--delay', type=float, default=0, help='Delay between repeats')
        parser.add_argument('command', nargs='*', help='Command to repeat')

        try:
            parsed_args = parser.parse_args(args)

            if parsed_args.help:
                print("""Usage: repeat [-h] [-t <times>] [-d <delay>] <command>

OPTIONS:
    -h, --help           Show this help information.
    -t, --times <num>    Number of times to repeat (default: 1).
    -d, --delay <sec>    Delay between repeats in seconds (default: 0).

Examples:
  repeat -t 5 show auxiliary
  repeat -t 3 -d 1.5 sessions -l
  repeat -t 10 -d 0.5 jobs""")
                return

            if not parsed_args.command:
                print("Error: Command is required")
                return

            command_str = ' '.join(parsed_args.command)
            print(f"Repeating '{command_str}' {parsed_args.times} times with {parsed_args.delay}s delay")

            for i in range(parsed_args.times):
                if i > 0 and parsed_args.delay > 0:
                    time.sleep(parsed_args.delay)
                print(f"--- Execution {i+1}/{parsed_args.times} ---")
                self.execute_command(command_str)

        except SystemExit:
            pass
        except Exception as e:
            print(f"Repeat command error: {e}")

    def do_route(self, args):
        """Route traffic through sessions with flags support"""
        parser = argparse.ArgumentParser(prog='route', add_help=False)
        parser.add_argument('-h', '--help', action='store_true', help='Show help')
        parser.add_argument('-a', '--add', action='store_true', help='Add route')
        parser.add_argument('-d', '--delete', action='store_true', help='Delete route')
        parser.add_argument('-l', '--list', action='store_true', help='List routes')
        parser.add_argument('-s', '--session', help='Session ID')
        parser.add_argument('subnet', nargs='?', help='Subnet to route')

        try:
            parsed_args = parser.parse_args(args)

            if parsed_args.help:
                print("""Usage: route [-h] [-a] [-d] [-l] [-s <session>] [subnet]

OPTIONS:
    -h, --help           Show this help information.
    -a, --add            Add a new route.
    -d, --delete         Delete a route.
    -l, --list           List all routes.
    -s, --session <id>   Session ID to route through.

Examples:
  route -l
  route -a -s 1 192.168.1.0/24
  route -d 192.168.1.0/24""")
                return

            if parsed_args.list:
                print("Active routes:")
                print("  No routes configured")
            elif parsed_args.add:
                print(f"Adding route for {parsed_args.subnet} via session {parsed_args.session}")
            elif parsed_args.delete:
                print(f"Deleting route for {parsed_args.subnet}")
            else:
                print("Route functionality - basic implementation")

        except SystemExit:
            pass
        except Exception as e:
            print(f"Route command error: {e}")

    def do_save(self, args):
        """Save datastores with flags support"""
        parser = argparse.ArgumentParser(prog='save', add_help=False)
        parser.add_argument('-h', '--help', action='store_true', help='Show help')
        parser.add_argument('-f', '--file', help='Save to specific file')
        parser.add_argument('-t', '--type', choices=['xml', 'json', 'csv'], default='xml', help='Output format')
        parser.add_argument('-w', '--workspace', help='Workspace to save')

        try:
            parsed_args = parser.parse_args(args)

            if parsed_args.help:
                print("""Usage: save [-h] [-f <file>] [-t <type>] [-w <workspace>]

OPTIONS:
    -h, --help              Show this help information.
    -f, --file <file>       Save to specific file.
    -t, --type <type>       Output format (xml, json, csv).
    -w, --workspace <name>  Workspace to save.

Examples:
  save
  save -f /tmp/results.xml
  save -t json -f results.json
  save -w project1""")
                return

            workspace = parsed_args.workspace or self.workspace
            file_type = parsed_args.type
            filename = parsed_args.file or f"exploitdf_save.{file_type}"

            print(f"Saving workspace '{workspace}' to {filename} ({file_type} format)")
            print("Save functionality - basic implementation")

        except SystemExit:
            pass
        except Exception as e:
            print(f"Save command error: {e}")

    def do_sessions(self, args):
        """Manage sessions with flags support"""
        parser = argparse.ArgumentParser(prog='sessions', add_help=False)
        parser.add_argument('-h', '--help', action='store_true', help='Show help')
        parser.add_argument('-l', '--list', action='store_true', help='List sessions')
        parser.add_argument('-i', '--interact', help='Interact with session')
        parser.add_argument('-k', '--kill', help='Kill session')
        parser.add_argument('-v', '--verbose', action='store_true', help='Verbose output')

        try:
            parsed_args = parser.parse_args(args)

            if parsed_args.help:
                print("""Usage: sessions [-h] [-l] [-i <id>] [-k <id>] [-v]

OPTIONS:
    -h, --help           Show this help information.
    -l, --list           List all sessions.
    -i, --interact <id>  Interact with session.
    -k, --kill <id>      Kill a session.
    -v, --verbose        Show detailed session information.

Examples:
  sessions -l
  sessions -i 1
  sessions -k 2
  sessions -l -v""")
                return

            if parsed_args.kill:
                print(f"Killing session {parsed_args.kill}")
            elif parsed_args.interact:
                print(f"Interacting with session {parsed_args.interact}")
            else:
                print("Active sessions:")
                if self.sessions:
                    for sid, session in self.sessions.items():
                        if parsed_args.verbose:
                            print(f"  {sid}: {session.get('type', 'unknown')} - {session.get('info', 'no info')}")
                        else:
                            print(f"  {sid}: {session.get('type', 'unknown')}")
                else:
                    print("  No active sessions")

        except SystemExit:
            pass
        except Exception as e:
            print(f"Sessions command error: {e}")

    def do_sleep(self, args):
        """Sleep command with flags support"""
        parser = argparse.ArgumentParser(prog='sleep', add_help=False)
        parser.add_argument('-h', '--help', action='store_true', help='Show help')
        parser.add_argument('-v', '--verbose', action='store_true', help='Verbose output')
        parser.add_argument('seconds', nargs='?', type=float, help='Seconds to sleep')

        try:
            parsed_args = parser.parse_args(args)

            if parsed_args.help:
                print("""Usage: sleep [-h] [-v] <seconds>

OPTIONS:
    -h, --help      Show this help information.
    -v, --verbose   Show countdown during sleep.

Examples:
  sleep 5
  sleep -v 10.5
  sleep 0.5""")
                return

            if parsed_args.seconds is None:
                print("Error: Sleep time is required")
                return

            if parsed_args.verbose:
                print(f"Sleeping for {parsed_args.seconds} seconds...")

            time.sleep(parsed_args.seconds)

            if parsed_args.verbose:
                print("Sleep completed")

        except SystemExit:
            pass
        except Exception as e:
            print(f"Sleep command error: {e}")

    def do_spool(self, args):
        """Spool output to file with flags support"""
        parser = argparse.ArgumentParser(prog='spool', add_help=False)
        parser.add_argument('-h', '--help', action='store_true', help='Show help')
        parser.add_argument('-a', '--append', action='store_true', help='Append to file')
        parser.add_argument('-s', '--stop', action='store_true', help='Stop spooling')
        parser.add_argument('file', nargs='?', help='Output file')

        try:
            parsed_args = parser.parse_args(args)

            if parsed_args.help:
                print("""Usage: spool [-h] [-a] [-s] [file]

OPTIONS:
    -h, --help      Show this help information.
    -a, --append    Append to existing file.
    -s, --stop      Stop current spooling.

Examples:
  spool /tmp/output.log
  spool -a results.txt
  spool -s""")
                return

            if parsed_args.stop:
                if self.spool_file:
                    print(f"Stopped spooling to {self.spool_file}")
                    self.spool_file = None
                else:
                    print("No active spooling")
            elif parsed_args.file:
                mode = 'a' if parsed_args.append else 'w'
                self.spool_file = parsed_args.file
                print(f"Spooling to {parsed_args.file} ({'append' if parsed_args.append else 'overwrite'} mode)")
            else:
                if self.spool_file:
                    print(f"Currently spooling to: {self.spool_file}")
                else:
                    print("No active spooling")

        except SystemExit:
            pass
        except Exception as e:
            print(f"Spool command error: {e}")

    def do_threads(self, args):
        """Manage background threads with flags support"""
        parser = argparse.ArgumentParser(prog='threads', add_help=False)
        parser.add_argument('-h', '--help', action='store_true', help='Show help')
        parser.add_argument('-l', '--list', action='store_true', help='List threads')
        parser.add_argument('-k', '--kill', help='Kill thread')
        parser.add_argument('-v', '--verbose', action='store_true', help='Verbose output')

        try:
            parsed_args = parser.parse_args(args)

            if parsed_args.help:
                print("""Usage: threads [-h] [-l] [-k <id>] [-v]

OPTIONS:
    -h, --help        Show this help information.
    -l, --list        List all threads.
    -k, --kill <id>   Kill a specific thread.
    -v, --verbose     Show detailed thread information.

Examples:
  threads -l
  threads -k 1
  threads -l -v""")
                return

            if parsed_args.kill:
                print(f"Killing thread {parsed_args.kill}")
            else:
                print("Background threads:")
                active_threads = threading.enumerate()
                if len(active_threads) > 1:  # Main thread always exists
                    for i, thread in enumerate(active_threads[1:], 1):
                        if parsed_args.verbose:
                            print(f"  {i}: {thread.name} - {'alive' if thread.is_alive() else 'dead'}")
                        else:
                            print(f"  {i}: {thread.name}")
                else:
                    print("  No background threads")

        except SystemExit:
            pass
        except Exception as e:
            print(f"Threads command error: {e}")

    def do_tips(self, args):
        """Show productivity tips with flags support"""
        parser = argparse.ArgumentParser(prog='tips', add_help=False)
        parser.add_argument('-h', '--help', action='store_true', help='Show help')
        parser.add_argument('-r', '--random', action='store_true', help='Show random tip')
        parser.add_argument('-a', '--all', action='store_true', help='Show all tips')
        parser.add_argument('-c', '--category', help='Show tips for category')

        try:
            parsed_args = parser.parse_args(args)

            if parsed_args.help:
                print("""Usage: tips [-h] [-r] [-a] [-c <category>]

OPTIONS:
    -h, --help              Show this help information.
    -r, --random            Show a random tip.
    -a, --all               Show all available tips.
    -c, --category <cat>    Show tips for specific category.

Examples:
  tips
  tips -r
  tips -a
  tips -c modules""")
                return

            tips_db = {
                'general': [
                    "Use 'help <command>' for detailed information about any command",
                    "Tab completion works for commands and module names",
                    "Use 'search <term>' to find modules quickly"
                ],
                'modules': [
                    "Use 'show auxiliary' to see all auxiliary modules",
                    "Set global variables with 'setg' to avoid repeating values",
                    "Use 'info' to see detailed module information and options"
                ],
                'sessions': [
                    "Use 'sessions -l' to list all active sessions",
                    "Background jobs with 'jobs' command for long-running tasks"
                ]
            }

            if parsed_args.all:
                for category, tips in tips_db.items():
                    print(f"\n{category.title()} Tips:")
                    for tip in tips:
                        print(f"  • {tip}")
            elif parsed_args.category:
                if parsed_args.category in tips_db:
                    print(f"{parsed_args.category.title()} Tips:")
                    for tip in tips_db[parsed_args.category]:
                        print(f"  • {tip}")
                else:
                    print(f"No tips found for category: {parsed_args.category}")
            else:
                import random
                all_tips = []
                for tips in tips_db.values():
                    all_tips.extend(tips)
                if parsed_args.random:
                    print(f"Tip: {random.choice(all_tips)}")
                else:
                    print(f"Tip: {all_tips[0]}")

        except SystemExit:
            pass
        except Exception as e:
            print(f"Tips command error: {e}")

    def do_unload(self, args):
        """Unload framework plugins with flags support"""
        parser = argparse.ArgumentParser(prog='unload', add_help=False)
        parser.add_argument('-h', '--help', action='store_true', help='Show help')
        parser.add_argument('-f', '--force', action='store_true', help='Force unload')
        parser.add_argument('-v', '--verbose', action='store_true', help='Verbose output')
        parser.add_argument('plugin', nargs='?', help='Plugin name to unload')

        try:
            parsed_args = parser.parse_args(args)

            if parsed_args.help:
                print("""Usage: unload [-h] [-f] [-v] <plugin>

OPTIONS:
    -h, --help      Show this help information.
    -f, --force     Force unload even if in use.
    -v, --verbose   Show detailed unloading information.

Examples:
  unload db_sqlite
  unload -f -v custom_plugin""")
                return

            if not parsed_args.plugin:
                print("Error: Plugin name is required")
                return

            print(f"Unloading plugin: {parsed_args.plugin}")
            if parsed_args.verbose:
                print(f"Force unload: {parsed_args.force}")
            print("Unload functionality - basic implementation")

        except SystemExit:
            pass
        except Exception as e:
            print(f"Unload command error: {e}")

    def do_advanced(self, args):
        """Show advanced options with flags support"""
        parser = argparse.ArgumentParser(prog='advanced', add_help=False)
        parser.add_argument('-h', '--help', action='store_true', help='Show help')
        parser.add_argument('-m', '--module', help='Show advanced options for module')

        try:
            parsed_args = parser.parse_args(args)

            if parsed_args.help:
                print("""Usage: advanced [-h] [-m <module>]

OPTIONS:
    -h, --help           Show this help information.
    -m, --module <name>  Show advanced options for specific module.

Examples:
  advanced
  advanced -m scanners/port_scanner""")
                return

            if parsed_args.module:
                if parsed_args.module in self.modules:
                    module = self.modules[parsed_args.module]()
                    module.show_advanced_options()
                else:
                    print(f"Module not found: {parsed_args.module}")
            elif self.current_module:
                self.current_module.show_advanced_options()
            else:
                print("No advanced options available (no module selected)")

        except SystemExit:
            pass
        except Exception as e:
            print(f"Advanced command error: {e}")

    def do_clearm(self, args):
        """Clear module stack with flags support"""
        parser = argparse.ArgumentParser(prog='clearm', add_help=False)
        parser.add_argument('-h', '--help', action='store_true', help='Show help')

        try:
            parsed_args = parser.parse_args(args)

            if parsed_args.help:
                print("""Usage: clearm [-h]

OPTIONS:
    -h, --help      Show this help information.

Examples:
  clearm""")
                return

            self.module_stack.clear()
            print("Module stack cleared")

        except SystemExit:
            pass
        except Exception as e:
            print(f"Clearm command error: {e}")

    def do_favorite(self, args):
        """Add module to favorites with flags support"""
        parser = argparse.ArgumentParser(prog='favorite', add_help=False)
        parser.add_argument('-h', '--help', action='store_true', help='Show help')
        parser.add_argument('-d', '--delete', action='store_true', help='Remove from favorites')
        parser.add_argument('module', nargs='?', help='Module name')

        try:
            parsed_args = parser.parse_args(args)

            if parsed_args.help:
                print("""Usage: favorite [-h] [-d] [module]

OPTIONS:
    -h, --help      Show this help information.
    -d, --delete    Remove module from favorites.

Examples:
  favorite scanners/port_scanner
  favorite -d auxiliary/http_title""")
                return

            module_name = parsed_args.module or (self.current_module.info['name'] if self.current_module else None)

            if not module_name:
                print("Error: Module name is required")
                return

            if parsed_args.delete:
                if module_name in self.favorites:
                    self.favorites.remove(module_name)
                    print(f"Removed {module_name} from favorites")
                else:
                    print(f"{module_name} is not in favorites")
            else:
                if module_name not in self.favorites:
                    self.favorites.append(module_name)
                    print(f"Added {module_name} to favorites")
                else:
                    print(f"{module_name} is already in favorites")

        except SystemExit:
            pass
        except Exception as e:
            print(f"Favorite command error: {e}")

    def do_favorites(self, args):
        """Show favorite modules with flags support"""
        parser = argparse.ArgumentParser(prog='favorites', add_help=False)
        parser.add_argument('-h', '--help', action='store_true', help='Show help')
        parser.add_argument('-c', '--clear', action='store_true', help='Clear all favorites')

        try:
            parsed_args = parser.parse_args(args)

            if parsed_args.help:
                print("""Usage: favorites [-h] [-c]

OPTIONS:
    -h, --help      Show this help information.
    -c, --clear     Clear all favorite modules.

Examples:
  favorites
  favorites -c""")
                return

            if parsed_args.clear:
                self.favorites.clear()
                print("All favorites cleared")
            else:
                if self.favorites:
                    print("Favorite modules:")
                    for fav in self.favorites:
                        print(f"  {fav}")
                else:
                    print("No favorite modules")

        except SystemExit:
            pass
        except Exception as e:
            print(f"Favorites command error: {e}")

    def do_listm(self, args):
        """List modules (alias for show)"""
        self.do_show(args)

    def do_loadpath(self, args):
        """Manage module load paths with flags support"""
        parser = argparse.ArgumentParser(prog='loadpath', add_help=False)
        parser.add_argument('-h', '--help', action='store_true', help='Show help')
        parser.add_argument('-a', '--add', help='Add path')
        parser.add_argument('-d', '--delete', help='Remove path')
        parser.add_argument('-l', '--list', action='store_true', help='List paths')

        try:
            parsed_args = parser.parse_args(args)

            if parsed_args.help:
                print("""Usage: loadpath [-h] [-a <path>] [-d <path>] [-l]

OPTIONS:
    -h, --help         Show this help information.
    -a, --add <path>   Add a module search path.
    -d, --delete <path> Remove a module search path.
    -l, --list         List all module search paths.

Examples:
  loadpath -l
  loadpath -a /custom/modules
  loadpath -d /old/modules""")
                return

            if parsed_args.add:
                if parsed_args.add not in self.loadpaths:
                    self.loadpaths.append(parsed_args.add)
                    print(f"Added path: {parsed_args.add}")
                else:
                    print(f"Path already exists: {parsed_args.add}")
            elif parsed_args.delete:
                if parsed_args.delete in self.loadpaths:
                    self.loadpaths.remove(parsed_args.delete)
                    print(f"Removed path: {parsed_args.delete}")
                else:
                    print(f"Path not found: {parsed_args.delete}")
            else:
                print("Module search paths:")
                for path in self.loadpaths:
                    print(f"  {path}")

        except SystemExit:
            pass
        except Exception as e:
            print(f"Loadpath command error: {e}")

    def do_popm(self, args):
        """Pop module from stack with flags support"""
        parser = argparse.ArgumentParser(prog='popm', add_help=False)
        parser.add_argument('-h', '--help', action='store_true', help='Show help')

        try:
            parsed_args = parser.parse_args(args)

            if parsed_args.help:
                print("""Usage: popm [-h]

OPTIONS:
    -h, --help      Show this help information.

Examples:
  popm""")
                return

            if self.module_stack:
                module = self.module_stack.pop()
                print(f"Popped module: {module}")
                if self.module_stack:
                    self.current_module = self.module_stack[-1]
                else:
                    self.current_module = None
            else:
                print("Module stack is empty")

        except SystemExit:
            pass
        except Exception as e:
            print(f"Popm command error: {e}")

    def do_previous(self, args):
        """Set previous module as current with flags support"""
        parser = argparse.ArgumentParser(prog='previous', add_help=False)
        parser.add_argument('-h', '--help', action='store_true', help='Show help')

        try:
            parsed_args = parser.parse_args(args)

            if parsed_args.help:
                print("""Usage: previous [-h]

OPTIONS:
    -h, --help      Show this help information.

Examples:
  previous""")
                return

            if len(self.module_stack) >= 2:
                previous_module = self.module_stack[-2]
                self.current_module = previous_module
                print(f"Set previous module: {previous_module.info['name']}")
            else:
                print("No previous module available")

        except SystemExit:
            pass
        except Exception as e:
            print(f"Previous command error: {e}")

    def do_pushm(self, args):
        """Push module to stack with flags support"""
        parser = argparse.ArgumentParser(prog='pushm', add_help=False)
        parser.add_argument('-h', '--help', action='store_true', help='Show help')
        parser.add_argument('module', nargs='?', help='Module to push')

        try:
            parsed_args = parser.parse_args(args)

            if parsed_args.help:
                print("""Usage: pushm [-h] [module]

OPTIONS:
    -h, --help      Show this help information.

Examples:
  pushm
  pushm scanners/port_scanner""")
                return

            if parsed_args.module:
                if parsed_args.module in self.modules:
                    module = self.modules[parsed_args.module]()
                    self.module_stack.append(module)
                    print(f"Pushed module: {parsed_args.module}")
                else:
                    print(f"Module not found: {parsed_args.module}")
            elif self.current_module:
                self.module_stack.append(self.current_module)
                print(f"Pushed current module: {self.current_module.info['name']}")
            else:
                print("No module to push")

        except SystemExit:
            pass
        except Exception as e:
            print(f"Pushm command error: {e}")

    def do_reload_all(self, args):
        """Reload all modules with flags support"""
        parser = argparse.ArgumentParser(prog='reload_all', add_help=False)
        parser.add_argument('-h', '--help', action='store_true', help='Show help')
        parser.add_argument('-v', '--verbose', action='store_true', help='Verbose output')

        try:
            parsed_args = parser.parse_args(args)

            if parsed_args.help:
                print("""Usage: reload_all [-h] [-v]

OPTIONS:
    -h, --help      Show this help information.
    -v, --verbose   Show detailed reload information.

Examples:
  reload_all
  reload_all -v""")
                return

            if parsed_args.verbose:
                print("Reloading all modules...")

            old_count = len(self.modules)
            self.load_modules()
            new_count = len(self.modules)

            print(f"Reloaded {new_count} modules (was {old_count})")

        except SystemExit:
            pass
        except Exception as e:
            print(f"Reload_all command error: {e}")

    def do_handler(self, args):
        """Start payload handler as job with flags support"""
        parser = argparse.ArgumentParser(prog='handler', add_help=False)
        parser.add_argument('-h', '--help', action='store_true', help='Show help')
        parser.add_argument('-p', '--payload', help='Payload type')
        parser.add_argument('-H', '--host', help='Listen host')
        parser.add_argument('-P', '--port', type=int, help='Listen port')

        try:
            parsed_args = parser.parse_args(args)

            if parsed_args.help:
                print("""Usage: handler [-h] [-p <payload>] [-H <host>] [-P <port>]

OPTIONS:
    -h, --help           Show this help information.
    -p, --payload <type> Payload type to handle.
    -H, --host <host>    Host to listen on.
    -P, --port <port>    Port to listen on.

Examples:
  handler -p reverse_tcp -H 0.0.0.0 -P 4444
  handler -p bind_tcp -P 4445""")
                return

            payload = parsed_args.payload or "reverse_tcp"
            host = parsed_args.host or "0.0.0.0"
            port = parsed_args.port or 4444

            job_id = len(self.jobs) + 1
            self.jobs[job_id] = {
                'type': 'handler',
                'payload': payload,
                'host': host,
                'port': port,
                'status': 'running'
            }

            print(f"Started handler job {job_id}: {payload} on {host}:{port}")

        except SystemExit:
            pass
        except Exception as e:
            print(f"Handler command error: {e}")

    def do_jobs(self, args):
        """Display and manage jobs with flags support"""
        parser = argparse.ArgumentParser(prog='jobs', add_help=False)
        parser.add_argument('-h', '--help', action='store_true', help='Show help')
        parser.add_argument('-l', '--list', action='store_true', help='List jobs')
        parser.add_argument('-k', '--kill', help='Kill job')
        parser.add_argument('-v', '--verbose', action='store_true', help='Verbose output')

        try:
            parsed_args = parser.parse_args(args)

            if parsed_args.help:
                print("""Usage: jobs [-h] [-l] [-k <id>] [-v]

OPTIONS:
    -h, --help        Show this help information.
    -l, --list        List all jobs.
    -k, --kill <id>   Kill a specific job.
    -v, --verbose     Show detailed job information.

Examples:
  jobs -l
  jobs -k 1
  jobs -l -v""")
                return

            if parsed_args.kill:
                job_id = int(parsed_args.kill)
                if job_id in self.jobs:
                    del self.jobs[job_id]
                    print(f"Killed job {job_id}")
                else:
                    print(f"Job {job_id} not found")
            else:
                print("Active jobs:")
                if self.jobs:
                    for job_id, job in self.jobs.items():
                        if parsed_args.verbose:
                            print(f"  {job_id}: {job['type']} - {job.get('status', 'unknown')} - {job.get('payload', 'N/A')}")
                        else:
                            print(f"  {job_id}: {job['type']}")
                else:
                    print("  No active jobs")

        except SystemExit:
            pass
        except Exception as e:
            print(f"Jobs command error: {e}")

    def do_kill(self, args):
        """Kill job with flags support"""
        parser = argparse.ArgumentParser(prog='kill', add_help=False)
        parser.add_argument('-h', '--help', action='store_true', help='Show help')
        parser.add_argument('job_id', nargs='?', help='Job ID to kill')

        try:
            parsed_args = parser.parse_args(args)

            if parsed_args.help:
                print("""Usage: kill [-h] <job_id>

OPTIONS:
    -h, --help      Show this help information.

Examples:
  kill 1
  kill 3""")
                return

            if not parsed_args.job_id:
                print("Error: Job ID is required")
                return

            job_id = int(parsed_args.job_id)
            if job_id in self.jobs:
                del self.jobs[job_id]
                print(f"Killed job {job_id}")
            else:
                print(f"Job {job_id} not found")

        except SystemExit:
            pass
        except ValueError:
            print("Error: Invalid job ID")
        except Exception as e:
            print(f"Kill command error: {e}")

    def do_rename_job(self, args):
        """Rename job with flags support"""
        parser = argparse.ArgumentParser(prog='rename_job', add_help=False)
        parser.add_argument('-h', '--help', action='store_true', help='Show help')
        parser.add_argument('job_id', nargs='?', help='Job ID to rename')
        parser.add_argument('new_name', nargs='?', help='New job name')

        try:
            parsed_args = parser.parse_args(args)

            if parsed_args.help:
                print("""Usage: rename_job [-h] <job_id> <new_name>

OPTIONS:
    -h, --help      Show this help information.

Examples:
  rename_job 1 "Port Scanner"
  rename_job 2 "HTTP Handler" """)
                return

            if not parsed_args.job_id or not parsed_args.new_name:
                print("Error: Job ID and new name are required")
                return

            job_id = int(parsed_args.job_id)
            if job_id in self.jobs:
                self.jobs[job_id]['name'] = parsed_args.new_name
                print(f"Renamed job {job_id} to '{parsed_args.new_name}'")
            else:
                print(f"Job {job_id} not found")

        except SystemExit:
            pass
        except ValueError:
            print("Error: Invalid job ID")
        except Exception as e:
            print(f"Rename_job command error: {e}")

    def do_dns(self, args):
        """Manage DNS resolver with flags support"""
        parser = argparse.ArgumentParser(prog='dns', add_help=False)
        parser.add_argument('-h', '--help', action='store_true', help='Show help')
        parser.add_argument('-a', '--add', help='Add DNS server')
        parser.add_argument('-d', '--delete', help='Remove DNS server')
        parser.add_argument('-l', '--list', action='store_true', help='List DNS servers')
        parser.add_argument('-r', '--resolve', help='Resolve hostname')

        try:
            parsed_args = parser.parse_args(args)

            if parsed_args.help:
                print("""Usage: dns [-h] [-a <server>] [-d <server>] [-l] [-r <hostname>]

OPTIONS:
    -h, --help              Show this help information.
    -a, --add <server>      Add DNS server.
    -d, --delete <server>   Remove DNS server.
    -l, --list              List configured DNS servers.
    -r, --resolve <host>    Resolve hostname to IP.

Examples:
  dns -l
  dns -a 8.8.8.8
  dns -r google.com
  dns -d 1.1.1.1""")
                return

            if parsed_args.add:
                print(f"Added DNS server: {parsed_args.add}")
            elif parsed_args.delete:
                print(f"Removed DNS server: {parsed_args.delete}")
            elif parsed_args.resolve:
                try:
                    import socket
                    ip = socket.gethostbyname(parsed_args.resolve)
                    print(f"{parsed_args.resolve} resolves to {ip}")
                except socket.gaierror:
                    print(f"Failed to resolve {parsed_args.resolve}")
            else:
                print("DNS servers:")
                print("  8.8.8.8 (Google)")
                print("  1.1.1.1 (Cloudflare)")

        except SystemExit:
            pass
        except Exception as e:
            print(f"DNS command error: {e}")


def main():
    """Main entry point"""
    framework = ExploitDF()
    framework.run()


if __name__ == "__main__":
    main()