eva-exploit 3.4.2__tar.gz → 3.4.3__tar.gz

{eva_exploit-3.4.2 → eva_exploit-3.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: eva-exploit
-Version: 3.4.2
+Version: 3.4.3
 Summary: Exploit Vector Agent
 Author: ARCANGEL0
 License: MIT

{eva_exploit-3.4.2 → eva_exploit-3.4.3}/config.py

@@ -10,7 +10,7 @@ from pathlib import Path
 
 # ================= CONFIG =================
 APP_NAME = "EVA"
-APP_VERSION = "3.4.2"
+APP_VERSION = "3.4.3"
 GITHUB_REPO = "arcangel0/EVA"
 PYPI_PACKAGE = "eva-exploit"
 API_ENDPOINT = "NOT_SET"

{eva_exploit-3.4.2 → eva_exploit-3.4.3}/eva_exploit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: eva-exploit
-Version: 3.4.2
+Version: 3.4.3
 Summary: Exploit Vector Agent
 Author: ARCANGEL0
 License: MIT

{eva_exploit-3.4.2 → eva_exploit-3.4.3}/modules/llm.py

@@ -703,10 +703,59 @@ def _query_g4f(history):
     return ""
 
 
-def _query_custom_api(history, prompt_text=""):
+def normalize_util(session_name):
+    suffix = re.sub(r"[^A-Za-z0-9_]", "_", str(session_name or "").strip())
+    suffix = re.sub(r"_+", "_", suffix).strip("_")
+    return suffix
+
+
+def custom_enpdoint_func(session_name=""):
     endpoint = str(getattr(config_module, "API_ENDPOINT", API_ENDPOINT) or "").strip()
     if endpoint == "NOT_SET":
         endpoint = ""
+
+    session_name = str(session_name or "").strip()
+    if session_name:
+        session_key = f"EVA_API_CUSTOMAPI_{session_name}"
+        session_endpoint = os.getenv(session_key, "").strip()
+        if session_endpoint:
+            return session_endpoint
+
+        normalized_suffix = normalize_util(session_name)
+        if normalized_suffix and normalized_suffix != session_name:
+            normalized_key = f"EVA_API_CUSTOMAPI_{normalized_suffix}"
+            normalized_endpoint = os.getenv(normalized_key, "").strip()
+            if normalized_endpoint:
+                return normalized_endpoint
+
+    return endpoint
+
+
+def _call_custom_api_handler(query_fn, history, endpoint, prompt_text, session_name):
+    attempts = [
+        lambda: query_fn(history=history, endpoint=endpoint, prompt=prompt_text, session=session_name),
+        lambda: query_fn(history=history, endpoint=endpoint, session=session_name, prompt=prompt_text),
+        lambda: query_fn(history=history, endpoint=endpoint, prompt=prompt_text),
+        lambda: query_fn(history=history, endpoint=endpoint),
+        lambda: query_fn(history, endpoint, prompt_text, session_name),
+        lambda: query_fn(history, endpoint, prompt_text),
+        lambda: query_fn(history, endpoint),
+        lambda: query_fn(history),
+    ]
+    last_type_error = None
+    for call in attempts:
+        try:
+            return call()
+        except TypeError as e:
+            last_type_error = e
+
+    if last_type_error is not None:
+        raise last_type_error
+    return ""
+
+
+def _query_custom_api(history, prompt_text="", session_name=""):
+    endpoint = custom_enpdoint_func(session_name=session_name)
     handler_path = str(getattr(config_module, "CUSTOM_API_HANDLER", CUSTOM_API_HANDLER) or "").strip()
 
     if handler_path and handler_path != "NOT_SET":
@@ -720,19 +769,13 @@ def _query_custom_api(history, prompt_text=""):
                     spec.loader.exec_module(module)
                     query_fn = getattr(module, "query_custom_api", None)
                     if callable(query_fn):
-                        try:
-                            result = query_fn(history=history, endpoint=endpoint, prompt=prompt_text)
-                        except TypeError:
-                            try:
-                                result = query_fn(history=history, endpoint=endpoint)
-                            except TypeError:
-                                try:
-                                    result = query_fn(history, endpoint, prompt_text)
-                                except TypeError:
-                                    try:
-                                        result = query_fn(history, endpoint)
-                                    except TypeError:
-                                        result = query_fn(history)
+                        result = _call_custom_api_handler(
+                            query_fn,
+                            history=history,
+                            endpoint=endpoint,
+                            prompt_text=prompt_text,
+                            session_name=session_name,
+                        )
                         if isinstance(result, (dict, list)):
                             return json.dumps(result)
                         if result is None:
@@ -745,7 +788,7 @@ def _query_custom_api(history, prompt_text=""):
         print(Fore.RED + "⚠️ Custom API endpoint is not configured.")
         return ""
 
-    payload = {"conversation": history, "prompt": prompt_text}
+    payload = {"conversation": history, "prompt": prompt_text, "session": session_name}
     r = requests.post(endpoint, json=payload, timeout=None)
     return r.text
 
@@ -855,10 +898,14 @@ def _query_gemini(history):
 
 
 class LLM:
-    def __init__(self, backend):
+    def __init__(self, backend, session_name=""):
         self.backend = backend
+        self.session_name = str(session_name or "").strip()
         self.history = []
 
+    def set_session_name(self, session_name):
+        self.session_name = str(session_name or "").strip()
+
     def query(self, user_msg, last_output="", on_stream_start=None, workflow_context=""):
         followup = _is_followup_analysis_request(user_msg)
         if followup and (
@@ -917,7 +964,11 @@ class LLM:
             elif self.backend == "g4f":
                 raw = _query_g4f(request_messages)
             elif self.backend == "api":
-                raw = _query_custom_api(request_messages, prompt_text=prompt)
+                raw = _query_custom_api(
+                    request_messages,
+                    prompt_text=prompt,
+                    session_name=self.session_name,
+                )
             elif self.backend == "gpt":
                 raw = _query_openai(request_messages)
             elif self.backend == "anthropic":

{eva_exploit-3.4.2 → eva_exploit-3.4.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "eva-exploit"
-version = "3.4.2"
+version = "3.4.3"
 description = "Exploit Vector Agent"
 readme = "README.md"
 requires-python = ">=3.10"

{eva_exploit-3.4.2 → eva_exploit-3.4.3}/sessions/eva_session.py

@@ -95,7 +95,7 @@ class Eva:
             self.memory = json.loads(session_path.read_text())
             self.backend = self.memory.get("backend", backend)
 
-        self.model = LLM(self.backend)
+        self.model = LLM(self.backend, self.sessionName)
         self._hydrate_model_context()
 
     def _hydrate_model_context(self):
@@ -164,7 +164,7 @@ class Eva:
             checkAPI()
             self.memory["backend"] = self.backend
             self.save()
-        self.model = LLM(self.backend)
+        self.model = LLM(self.backend, self.sessionName)
         self._hydrate_model_context()
 
     def rename_session(self):
@@ -189,6 +189,7 @@ class Eva:
         self.session_path.rename(new_path)
         self.session_path = new_path
         self.sessionName = new_name
+        self.model.set_session_name(self.sessionName)
         self.save()
         cyber(f"Session renamed to {new_name}", color=Fore.GREEN)
 

{eva_exploit-3.4.2 → eva_exploit-3.4.3}/utils/system.py

@@ -70,7 +70,7 @@ def _custom_api_template(endpoint):
         "#!/usr/bin/env python3\n"
         "import requests\n\n"
         f"API_ENDPOINT = {json.dumps(target)}\n\n"
-        "def query_custom_api(history, endpoint=None, prompt=None):\n"
+        "def query_custom_api(history, endpoint=None, session=None, prompt=None):\n"
         "    target = endpoint or API_ENDPOINT\n"
         "    compiled_prompt = str(prompt or \"\").strip()\n"
         "    if not compiled_prompt:\n"
@@ -81,7 +81,7 @@ def _custom_api_template(endpoint):
         "    payload = {\n"
         "        \"prompt\": compiled_prompt,\n"
         "        \"conversation\": history,\n"
-        "        \"session\": \"eva-session\",\n"
+        "        \"session\": session,\n"
         "    }\n"
         "    r = requests.post(target, json=payload, timeout=None)\n"
         "    try:\n"
@@ -249,11 +249,74 @@ def _is_newer(latest, current):
 _UPDATE_STATUS_CACHE = None
 
 
+def _module_git_root():
+    here = Path(__file__).resolve()
+    for base in (here.parent, *here.parents):
+        if (base / ".git").exists():
+            return base
+    return None
+
+
+def _installed_package_version():
+    try:
+        return metadata.version(PYPI_PACKAGE)
+    except metadata.PackageNotFoundError:
+        return None
+
+
+def _is_path_in_repo(raw_path, repo_root):
+    if not raw_path:
+        return False
+    try:
+        candidate = Path(raw_path).expanduser()
+        if not candidate.exists():
+            return False
+        candidate = candidate.resolve()
+        return candidate.is_relative_to(repo_root.resolve())
+    except OSError:
+        return False
+
+
+def _running_from_repo_checkout(repo_root):
+    main_module = sys.modules.get("__main__")
+    main_file = getattr(main_module, "__file__", "")
+    if _is_path_in_repo(main_file, repo_root):
+        return True
+    argv0 = sys.argv[0] if sys.argv else ""
+    if argv0 and Path(argv0).expanduser().exists() and _is_path_in_repo(argv0, repo_root):
+        return True
+    return False
+
+
+def _read_local_version(base_path):
+    pyproject = base_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 str(version).strip()
+        except (tomllib.TOMLDecodeError, OSError):
+            pass
+
+    cfg_path = base_path / "config.py"
+    if cfg_path.exists():
+        try:
+            raw = cfg_path.read_text(encoding="utf-8")
+        except OSError:
+            return None
+        match = re.search(r'^APP_VERSION\s*=\s*["\']([^"\']+)["\']', raw, flags=re.MULTILINE)
+        if match:
+            return match.group(1).strip()
+    return None
+
+
 def _git_branch():
-    if not Path(".git").exists():
+    repo_root = _module_git_root()
+    if repo_root is None:
         return "main"
     branch_detect = subprocess.run(
-        ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+        ["git", "-C", str(repo_root), "rev-parse", "--abbrev-ref", "HEAD"],
         capture_output=True,
         text=True
     )
@@ -263,13 +326,15 @@ def _git_branch():
 
 
 def _update_source():
-    if Path(".git").exists():
+    repo_root = _module_git_root()
+    installed_version = _installed_package_version()
+    if repo_root is not None and command_exists("git") and _running_from_repo_checkout(repo_root):
         return "github"
-    try:
-        metadata.version(PYPI_PACKAGE)
+    if installed_version:
         return "pypi"
-    except metadata.PackageNotFoundError:
+    if repo_root is not None and command_exists("git"):
         return "github"
+    return "pypi"
 
 
 def _can_reach_tls_host(host):
@@ -282,18 +347,25 @@ def _can_reach_tls_host(host):
 
 
 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
+    repo_root = _module_git_root()
+    installed_version = _installed_package_version()
+
+    if repo_root is not None and _running_from_repo_checkout(repo_root):
+        local_version = _read_local_version(repo_root)
+        if local_version:
+            return local_version
+
+    if installed_version:
+        return installed_version
+
+    if repo_root is not None:
+        local_version = _read_local_version(repo_root)
+        if local_version:
+            return local_version
+
+    local_version = _read_local_version(Path.cwd())
+    if local_version:
+        return local_version
     return APP_VERSION
 
 
@@ -339,7 +411,11 @@ def get_update_status(force=False):
         latest = None
     available = bool(latest) and _is_newer(latest, current)
 
-    command = f"git pull --tags origin {branch}" if source == "github" else "eva -u"
+    repo_root = _module_git_root()
+    if source == "github" and repo_root is not None:
+        command = f"git -C {shlex.quote(str(repo_root))} pull --tags origin {branch}"
+    else:
+        command = "eva -u"
     prefix = "|> Update github checkout running " if source == "github" else "|> Update eva to latest version running "
 
     _UPDATE_STATUS_CACHE = {
@@ -377,21 +453,22 @@ def run_self_update():
     source = status.get("source")
     print(Style.BRIGHT + Fore.MAGENTA + f"Update {latest} found! Installing . . . . " + Style.RESET_ALL)
 
+    repo_root = _module_git_root()
     updated = False
-    with open(os.devnull, "w") as devnull:
-        if source == "github" and Path(".git").exists() and command_exists("git"):
-            branch = _git_branch()
-            pull_result = subprocess.run(
-                ["git", "pull", "--tags", "origin", branch],
-                text=True
-            )
-            updated = pull_result.returncode == 0
-        else:
-            pip_result = subprocess.run(
-        [sys.executable, "-m", "pip", "install", "--upgrade", PYPI_PACKAGE,"--break-system-packages"],
-        text=True
-    )
-            updated = pip_result.returncode == 0
+    if source == "github" and repo_root is not None and command_exists("git"):
+        branch = _git_branch()
+        pull_result = subprocess.run(
+            ["git", "-C", str(repo_root), "pull", "--tags", "origin", branch],
+            text=True
+        )
+        updated = pull_result.returncode == 0
+    else:
+        pip_cmd = [sys.executable, "-m", "pip", "install", "--upgrade", PYPI_PACKAGE, "--break-system-packages"]
+        pip_result = subprocess.run(pip_cmd, text=True, capture_output=True)
+        if pip_result.returncode != 0 and "no such option: --break-system-packages" in (pip_result.stderr or "").lower():
+            pip_cmd = [sys.executable, "-m", "pip", "install", "--upgrade", PYPI_PACKAGE]
+            pip_result = subprocess.run(pip_cmd, text=True)
+        updated = pip_result.returncode == 0
 
     print(Fore.CYAN + "Almost done . . . . ")
     if updated:
@@ -402,7 +479,10 @@ def run_self_update():
 
     print(Fore.RED + "\n[!] Could not auto-update EVA in this environment.")
     if source == "github":
-        print(Fore.YELLOW + f"Try manually: git pull --tags origin {_git_branch()}")
+        if repo_root is not None:
+            print(Fore.YELLOW + f"Try manually: git -C {shlex.quote(str(repo_root))} pull --tags origin {_git_branch()}")
+        else:
+            print(Fore.YELLOW + f"Try manually: git pull --tags origin {_git_branch()}")
     else:
         print(Fore.YELLOW + f"Try manually: {sys.executable} -m pip install --upgrade {PYPI_PACKAGE}")
     return 1