eva-exploit 2.5__py3-none-any.whl

utils/system.py

@@ -0,0 +1,264 @@
+import json
+import os
+import socket
+import signal
+import subprocess
+import sys
+import time
+from importlib import metadata
+from pathlib import Path
+from urllib import error, request
+import tomllib
+
+from colorama import Fore
+
+from config import API_ENDPOINT, APP_NAME, APP_VERSION, ENV_PATH, OLLAMA_MODEL, PYPI_PACKAGE
+from utils.ui import clear, cyber
+
+
+# ═══════════════════════════════════════════════════════════════
+#  :: Utilities
+#  Utility functions such as ApiKEY verifier and signal handler
+# ═══════════════════════════════════════════════════════════════
+def checkAPI():
+    if API_ENDPOINT == "NOT_SET":
+        print(Fore.RED + "\nNo custom API set. Please configure in source code at API_ENPOINT")
+        sys.exit(0)
+
+
+def checkOpenAIKey():
+    key = os.getenv("OPENAI_API_KEY")
+    if key and key.strip():
+        return key.strip()
+    if ENV_PATH.exists():
+        for line in ENV_PATH.read_text().splitlines():
+            if line.startswith("OPENAI_API_KEY="):
+                key = line.split("=", 1)[1].strip()
+                if key:
+                    os.environ["OPENAI_API_KEY"] = key
+                    return key
+    os.system("clear")
+    cyber("OpenAI key not found! :: Please insert it below", color=Fore.RED)
+    print("\nYour OpenAI API key will be stored locally in .env\n")
+    key = input("#key > ").strip()
+    if not key:
+        print(Fore.RED + "\nNo key provided. Aborting.")
+        sys.exit(1)
+    with open(ENV_PATH, "a") as f:
+        f.write(f"\nOPENAI_API_KEY={key}\n")
+    os.environ["OPENAI_API_KEY"] = key
+    print(Fore.GREEN + "\n✔ OpenAI API key saved successfully.")
+    time.sleep(1)
+    return key
+
+
+def checkAnthropicKey():
+    key = os.getenv("ANTHROPIC_API_KEY")
+    if key and key.strip():
+        return key.strip()
+    if ENV_PATH.exists():
+        for line in ENV_PATH.read_text().splitlines():
+            if line.startswith("ANTHROPIC_API_KEY="):
+                key = line.split("=", 1)[1].strip()
+                if key:
+                    os.environ["ANTHROPIC_API_KEY"] = key
+                    return key
+    os.system("clear")
+    cyber("Anthropic key not found! :: Please insert it below", color=Fore.RED)
+    print("\nYour Anthropic API key will be stored locally in .env\n")
+    key = input("#key > ").strip()
+    if not key:
+        print(Fore.RED + "\nNo key provided. Aborting.")
+        sys.exit(1)
+    with open(ENV_PATH, "a") as f:
+        f.write(f"\nANTHROPIC_API_KEY={key}\n")
+    os.environ["ANTHROPIC_API_KEY"] = key
+    print(Fore.GREEN + "\n✔ Anthropic API key saved successfully.")
+    time.sleep(1)
+    return key
+
+
+def checkGeminiKey():
+    key = os.getenv("GEMINI_API_KEY")
+    if key and key.strip():
+        return key.strip()
+    if ENV_PATH.exists():
+        for line in ENV_PATH.read_text().splitlines():
+            if line.startswith("GEMINI_API_KEY="):
+                key = line.split("=", 1)[1].strip()
+                if key:
+                    os.environ["GEMINI_API_KEY"] = key
+                    return key
+    os.system("clear")
+    cyber("Gemini key not found! :: Please insert it below", color=Fore.RED)
+    print("\nYour Gemini API key will be stored locally in .env\n")
+    key = input("#key > ").strip()
+    if not key:
+        print(Fore.RED + "\nNo key provided. Aborting.")
+        sys.exit(1)
+    with open(ENV_PATH, "a") as f:
+        f.write(f"\nGEMINI_API_KEY={key}\n")
+    os.environ["GEMINI_API_KEY"] = key
+    print(Fore.GREEN + "\n✔ Gemini API key saved successfully.")
+    time.sleep(1)
+    return key
+
+
+def ctrl_c_handler(signum, frame):
+    raise KeyboardInterrupt
+
+
+def register_signal_handler():
+    signal.signal(signal.SIGINT, ctrl_c_handler)
+
+
+def graceful_exit():
+    cyber("EVA OFFLINE :: SESSION IS SAVED", color=Fore.RED)
+    print(Fore.YELLOW + "🜂  E x i t i n g  E V A ...")
+    time.sleep(2.5)
+    clear()
+    sys.exit(0)
+
+
+def _split_version(value):
+    clean = str(value).strip().lower().lstrip("v")
+    parts = []
+    for part in clean.split("."):
+        digits = ""
+        for char in part:
+            if char.isdigit():
+                digits += char
+            else:
+                break
+        parts.append(int(digits or 0))
+    while len(parts) < 3:
+        parts.append(0)
+    return tuple(parts[:3])
+
+
+def _is_newer(latest, current):
+    return _split_version(latest) > _split_version(current)
+
+
+def get_current_version():
+    try:
+        return metadata.version(PYPI_PACKAGE)
+    except metadata.PackageNotFoundError:
+        pyproject = Path("pyproject.toml")
+        if pyproject.exists():
+            try:
+                data = tomllib.loads(pyproject.read_text(encoding="utf-8"))
+                version = data.get("project", {}).get("version")
+                if version:
+                    return version
+            except (tomllib.TOMLDecodeError, OSError):
+                pass
+    return APP_VERSION
+
+
+def fetch_latest_pypi_version():
+    url = f"https://pypi.org/pypi/{PYPI_PACKAGE}/json"
+    req = request.Request(url, headers={"Accept": "application/json", "User-Agent": "eva-update-check"})
+    try:
+        with request.urlopen(req, timeout=5) as response:
+            data = json.loads(response.read().decode("utf-8"))
+            return data.get("info", {}).get("version")
+    except (error.URLError, TimeoutError, json.JSONDecodeError):
+        return None
+
+
+def checkupdts():
+    try:
+        socket.create_connection(("pypi.org", 443), timeout=2)
+    except OSError:
+        return
+
+    current = get_current_version()
+    latest = fetch_latest_pypi_version()
+    if not latest:
+        return
+    if _is_newer(latest, current):
+        print("\n" + Fore.CYAN + "=" * 40)
+        print(Fore.CYAN + f"🐱 Update available: {current} → {latest}")
+        print(Fore.GREEN + "Run: eva -u to update to the latest version")
+        print("=" * 40 + Fore.CYAN + "\n")
+
+
+def run_self_update():
+    print(Fore.CYAN + f"\nChecking updates for {APP_NAME}...\n")
+    updated = False
+
+    pip_result = subprocess.run(
+        [sys.executable, "-m", "pip", "install", "--upgrade", PYPI_PACKAGE],
+        text=True
+    )
+    if pip_result.returncode == 0:
+        updated = True
+
+    if Path(".git").exists() and command_exists("git"):
+        branch = "main"
+        branch_detect = subprocess.run(
+            ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+            capture_output=True,
+            text=True
+        )
+        if branch_detect.returncode == 0 and branch_detect.stdout.strip():
+            branch = branch_detect.stdout.strip()
+
+        pull_result = subprocess.run(["git", "pull", "--tags", "origin", branch], text=True)
+        if pull_result.returncode == 0:
+            updated = True
+
+    if updated:
+        print(Fore.GREEN + "\n✔ Update process finished. Restart EVA to use the latest version.")
+        return 0
+
+    print(Fore.RED + "\n[!] Could not auto-update EVA in this environment.")
+    print(Fore.YELLOW + f"Try manually: {sys.executable} -m pip install --upgrade {PYPI_PACKAGE}")
+    return 1
+
+
+# ================= STARTUP OF EVA here =================
+def command_exists(cmd):
+    return subprocess.call(
+        ["which", cmd],
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL
+    ) == 0
+
+
+def ollama_running():
+    try:
+        subprocess.check_output(['ollama', 'list'], stderr=subprocess.STDOUT, text=True)
+        return True
+    except subprocess.CalledProcessError as e:
+        if "server not responding" in e.output.lower():
+            return False
+        return False
+
+
+def start_ollama():
+    clear()
+    print("\n\n\n")
+    print(Fore.YELLOW + "🜂 OLLAMA NOT RUNNING :: Starting for you...\n\n")
+
+    with open(os.devnull, 'w') as DEVNULL:
+        subprocess.Popen(
+            ['ollama', 'serve'],
+            stdout=DEVNULL,
+            stderr=DEVNULL,
+            stdin=DEVNULL,
+            close_fds=True,
+            start_new_session=True
+        )
+
+    time.sleep(3)
+
+
+def model_exists():
+    r = subprocess.run(
+        ["ollama", "list"],
+        capture_output=True,
+        text=True
+    )
+    return OLLAMA_MODEL in r.stdout

utils/ui.py

@@ -0,0 +1,191 @@
+import os
+import re
+import sys
+import termios
+import tty
+import itertools
+import threading
+import time
+from colorama import Fore, Style, init
+
+init(autoreset=True)
+
+
+def clear():
+    os.system("clear")
+
+
+# ════════════════════
+#  :: UI FUNCTIONS
+# ════════════════════
+
+_spinner_frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+_spinner_text = " L o a d i n g "
+_spinner_delay = 0.10
+_spinner_running = False
+_spinner_thread = None
+
+
+def _spinner_animate():
+    for i, frame in enumerate(itertools.cycle(_spinner_frames)):
+        if not _spinner_running:
+            break
+        dot_count = (i // 3) % 4 + 1
+        dots = "." * dot_count
+        spaces = " " * (4 - dot_count)
+        sys.stdout.write(f"\r  {frame}  {_spinner_text}{dots}{spaces}")
+        sys.stdout.flush()
+        time.sleep(_spinner_delay)
+
+
+def spinner_start():
+    global _spinner_running, _spinner_thread
+    if _spinner_running:
+        return
+    _spinner_running = True
+    sys.stdout.write(f"\n\n")
+    _spinner_thread = threading.Thread(target=_spinner_animate)
+    _spinner_thread.daemon = True
+    _spinner_thread.start()
+
+
+def spinner_stop():
+    global _spinner_running
+    _spinner_running = False
+    if _spinner_thread:
+        _spinner_thread.join()
+    sys.stdout.write("\r" + " " * (len(_spinner_text) + 4) + "\r")
+    sys.stdout.flush()
+
+
+def cyber(msg="", width=50, color=Fore.GREEN):
+    """
+    Stylized output in a centered scifi box.
+    :param msg: message
+    :param width: width
+    :param color: Ccolor
+    """
+    width = int(width)
+    ansi_re = re.compile(r"\x1b\[[0-9;]*m")
+
+    def visible_len(text):
+        return len(ansi_re.sub("", text))
+
+    lines = str(msg).splitlines() if msg else []
+    longest = max((visible_len(line) for line in lines), default=0)
+    width = max(width, longest + 4)
+
+    print(color + "╔" + "═" * width + "╗")
+    if lines:
+        for line in lines:
+            line_len = visible_len(line)
+            content_len = line_len + 2
+            padding = max(0, width - content_len)
+            left_pad = padding // 2
+            right_pad = padding - left_pad
+            print(color + "║" + " " * left_pad + " " + line + " " + " " * right_pad + "║")
+    print(color + "╚" + "═" * width + "╝")
+    print(Style.RESET_ALL)
+
+
+
+def banner(version=None):
+    clear()
+    print(Style.BRIGHT + Fore.CYAN + rf"""
+╔═════════════════════════════════════════════╗
+║                                             ║
+║  ░▒▓████████▓▒░▒▓█▓▒░░▒▓█▓▒░░▒▓██████▓▒░    ║
+║  ░▒▓█▓▒░      ░▒▓█▓▒░░▒▓█▓▒░▒▓█▓▒░░▒▓█▓▒░   ║
+║  ░▒▓█▓▒░       ░▒▓█▓▒▒▓█▓▒░░▒▓█▓▒░░▒▓█▓▒░   ║
+║  ░▒▓██████▓▒░  ░▒▓█▓▒▒▓█▓▒░░▒▓████████▓▒░   ║
+║  ░▒▓█▓▒░        ░▒▓█▓▓█▓▒░ ░▒▓█▓▒░░▒▓█▓▒░   ║
+║  ░▒▓█▓▒░        ░▒▓█▓▓█▓▒░ ░▒▓█▓▒░░▒▓█▓▒░   ║
+║  ░▒▓████████▓▒░  ░▒▓██▓▒░  ░▒▓█▓▒░░▒▓█▓▒░   ║
+║                       Exploit Vector Agent  ║
+║                                             ║
+║ ᴍᴀᴅᴇ ʙʏ: 𝝺𝗿𝗰𝗮𝗻𝗴𝗲𝗹𝗼                          ║
+╚═════════════════════════════════════════════╝
+{Style.BRIGHT} {Fore.MAGENTA} version: {version} {Style.RESET_ALL} """)
+
+
+# ╔═════════░░░═════════╗
+# ░░░   Query input   ░░░
+# ╚═════════░░░═════════╝
+def raw_input(prompt=""):
+    fd = sys.stdin.fileno()
+    old = termios.tcgetattr(fd)
+    buf = ""
+    try:
+        tty.setcbreak(fd)
+        print(prompt, end="", flush=True)
+        while True:
+            ch = sys.stdin.read(1)
+            if ch in ("\n", "\r"):
+                print()
+                return buf
+            elif ch in ("\x7f", "\x08"):
+                if buf:
+                    buf = buf[:-1]
+                    print("\b \b", end="", flush=True)
+            elif ch == "\x03":
+                raise KeyboardInterrupt
+            else:
+                buf += ch
+                print(ch, end="", flush=True)
+    finally:
+        termios.tcsetattr(fd, termios.TCSADRAIN, old)
+
+
+# ╔═════════░░░═════════╗
+# ░░░ Control utilies ░░░
+# ╚═════════░░░═════════╝
+
+def menu(title, options):
+    idx = 0
+    fd = sys.stdin.fileno()
+    old = termios.tcgetattr(fd)
+    try:
+        tty.setcbreak(fd)
+        while True:
+            os.system("clear")
+            cyber(title)
+            for i, opt in enumerate(options):
+                prefix = "→ " if i == idx else "  "
+                print(prefix + opt)
+            ch = sys.stdin.read(1)
+            if ch == "\x1b":
+                sys.stdin.read(1)
+                arrow = sys.stdin.read(1)
+                if arrow == "A":
+                    idx = (idx - 1) % len(options)
+                elif arrow == "B":
+                    idx = (idx + 1) % len(options)
+            elif ch in ("\n", "\r"):
+                return idx
+    finally:
+        termios.tcsetattr(fd, termios.TCSADRAIN, old)
+def get_sessions(title, options, version=None):
+    idx = 0
+    fd = sys.stdin.fileno()
+    old = termios.tcgetattr(fd)
+    try:
+        tty.setcbreak(fd)
+        while True:
+            banner(version)
+            print("\n")
+            cyber(title)
+            for i, opt in enumerate(options):
+                prefix = "→ " if i == idx else "  "
+                print(prefix + opt)
+            ch = sys.stdin.read(1)
+            if ch == "\x1b":
+                sys.stdin.read(1)
+                arrow = sys.stdin.read(1)
+                if arrow == "A":
+                    idx = (idx - 1) % len(options)
+                elif arrow == "B":
+                    idx = (idx + 1) % len(options)
+            elif ch in ("\n", "\r"):
+                return idx
+    finally:
+        termios.tcsetattr(fd, termios.TCSADRAIN, old)