voidaccess 1.9.0__tar.gz → 1.9.1__tar.gz

{voidaccess-1.9.0/voidaccess.egg-info → voidaccess-1.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: voidaccess
-Version: 1.9.0
+Version: 1.9.1
 Summary: Dark web OSINT CLI — automated threat intelligence from query to report
 Author: VoidAccess
 License-Expression: MIT

{voidaccess-1.9.0 → voidaccess-1.9.1}/config.py

@@ -5,7 +5,7 @@ from dotenv import load_dotenv
 load_dotenv()
 
 logger = logging.getLogger(__name__)
-_OPTIONAL_CONFIG_WARNING_SHOWN = False
+_OPTIONAL_CONFIG_WARNING_STATE = "_voidaccess_optional_config_warning_shown"
 
 
 def _clean_env(name, default=None):
@@ -151,16 +151,12 @@ except ValueError:
 BLOCKCYPHER_TOKEN = _clean_env("BLOCKCYPHER_TOKEN", "")
 ETHERSCAN_API_KEY = _clean_env("ETHERSCAN_API_KEY", "")
 
-# Auth — REQUIRED in production. Generate with: python -c "import secrets; print(secrets.token_hex(32))"
-_jwt_secret = _clean_env("JWT_SECRET")
-if _jwt_secret is None:
-    raise RuntimeError(
-        "JWT_SECRET environment variable is not set. "
-        "Generate a secure secret with: python -c \"import secrets; print(secrets.token_hex(32))\" "
-        "and set it as JWT_SECRET in your .env file. "
-        "Do NOT use a random secret — it will change on restart and invalidate all issued tokens."
-    )
-JWT_SECRET = _jwt_secret
+# Auth — REQUIRED when the API/auth stack is actually used.  Do not validate
+# this at import time: the CLI injects its runtime environment in its entry
+# point before importing dependent modules, and `--help`/`--version` must work
+# on a fresh install.  `validate_config()` and the API startup path enforce it
+# at the point where authentication is needed.
+JWT_SECRET = _clean_env("JWT_SECRET")
 
 # Token blacklist Redis (optional — omit to disable blacklist checks)
 REDIS_URL = _clean_env("REDIS_URL")
@@ -210,7 +206,6 @@ OPTIONAL_KEYS = [
 
 
 def validate_config():
-    global _OPTIONAL_CONFIG_WARNING_SHOWN
     missing_required = []
     for key in REQUIRED_KEYS:
         if _clean_env(key) is None:
@@ -221,16 +216,14 @@ def validate_config():
         key for key in OPTIONAL_KEYS
         if (_clean_env(key) is None or _clean_env(key) == "")
     ]
-    if missing_optional and not _OPTIONAL_CONFIG_WARNING_SHOWN:
+    if missing_optional and not getattr(logging, _OPTIONAL_CONFIG_WARNING_STATE, False):
         logger.warning(
             "Optional configuration keys not set (%d): %s - related features will be disabled",
             len(missing_optional),
             ", ".join(missing_optional),
         )
-        _OPTIONAL_CONFIG_WARNING_SHOWN = True
-
-
-validate_config()
-
+        # Store the guard on the process-wide logging module so compatibility
+        # wrappers/reloads cannot reset it and reintroduce warning spam.
+        setattr(logging, _OPTIONAL_CONFIG_WARNING_STATE, True)
 
 

{voidaccess-1.9.0 → voidaccess-1.9.1}/db/session.py

@@ -38,6 +38,7 @@ Usage (testing — pass an explicit URL to avoid needing DATABASE_URL in env)
 from __future__ import annotations
 
 from functools import lru_cache
+import os
 
 from contextlib import asynccontextmanager, contextmanager
 from typing import AsyncGenerator, Generator, Optional
@@ -48,7 +49,19 @@ from sqlalchemy.orm import sessionmaker, Session
 
 import config
 
+# Kept as a compatibility/testing hook.  Production lookups below use the
+# current environment so apply_env() can run before the first DB operation.
 DATABASE_URL = config.DATABASE_URL
+_INITIAL_DATABASE_URL = DATABASE_URL
+
+
+def _database_url() -> Optional[str]:
+    # Preserve the long-standing test/embedding hook of monkeypatching this
+    # module's DATABASE_URL. Otherwise, read the live environment so a caller
+    # can inject DATABASE_URL after db.session has been imported.
+    if DATABASE_URL != _INITIAL_DATABASE_URL:
+        return DATABASE_URL
+    return os.getenv("DATABASE_URL") or DATABASE_URL
 _async_engine_cache: dict[str, "AsyncEngine"] = {}
 
 
@@ -104,7 +117,7 @@ def get_engine(url: Optional[str] = None) -> Engine:
     PostgreSQL gets a connection pool tuned for the scraping workload.
     SQLite skips pool parameters that only apply to QueuePool.
     """
-    target_url = url or DATABASE_URL
+    target_url = url or _database_url()
     if not target_url:
         raise RuntimeError(
             "DATABASE_URL is not configured.\n"
@@ -122,7 +135,7 @@ def release_engine(url: Optional[str] = None) -> None:
     Calls engine.dispose() to release connection pool resources and file handles,
     then clears the cache. Use this in test teardown to prevent leaks.
     """
-    target_url = url or DATABASE_URL
+    target_url = url or _database_url()
     if target_url:
         try:
             engine = get_engine(target_url)
@@ -139,7 +152,7 @@ def get_async_engine(url: Optional[str] = None) -> "AsyncEngine":
     Converts postgresql:// to postgresql+asyncpg:// and sqlite:// to sqlite+aiosqlite://.
     """
 
-    target_url = url or DATABASE_URL
+    target_url = url or _database_url()
     if not target_url:
         raise RuntimeError(
             "DATABASE_URL is not configured.\n"
@@ -185,7 +198,7 @@ def release_async_engine(url: Optional[str] = None) -> None:
 
     Calls engine.dispose() to release connection pool resources and file handles.
     """
-    target_url = url or DATABASE_URL
+    target_url = url or _database_url()
     if target_url in _async_engine_cache:
         _async_engine_cache[target_url].dispose()
         del _async_engine_cache[target_url]

{voidaccess-1.9.0 → voidaccess-1.9.1}/export/ioc_package.py

@@ -57,7 +57,7 @@ logger = logging.getLogger(__name__)
 # ---------------------------------------------------------------------------
 
 PACKAGE_FORMAT = "voidaccess-ioc-v1"
-PACKAGE_VERSION = "1.9.0"
+PACKAGE_VERSION = "1.9.1"
 SNORT_SID_BASE = 9000001  # 9xxxxxx reserved for VoidAccess-generated rules
 
 # Map extractor upper-case entity types to the per-file bucket they belong to.

{voidaccess-1.9.0 → voidaccess-1.9.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "voidaccess"
-version = "1.9.0"
+version = "1.9.1"
 description = "Dark web OSINT CLI — automated threat intelligence from query to report"
 readme = "README.md"
 license = "MIT"

{voidaccess-1.9.0 → voidaccess-1.9.1}/tests/test_config.py

@@ -3,6 +3,7 @@
 import os
 import sys
 import unittest
+import logging
 from unittest.mock import patch, MagicMock
 
 
@@ -52,6 +53,28 @@ class TestConfigValidation(unittest.TestCase):
                 warning_calls = str(mock_logger.warning.call_args_list)
                 self.assertIn("OPENAI_API_KEY", warning_calls)
 
+    def test_optional_config_warning_is_once_per_process(self):
+        """Repeated validation must not spam the same process with warnings."""
+        import config
+
+        with patch.dict(os.environ, {"JWT_SECRET": "test-secret-key-123"}, clear=True):
+            # The guard intentionally lives on logging so compatibility-module
+            # reloads cannot reset it; reset it explicitly for this isolated
+            # regression test.
+            setattr(logging, "_voidaccess_optional_config_warning_shown", False)
+            try:
+                with patch.object(config, "logger") as mock_logger:
+                    config.validate_config()
+                    config.validate_config()
+
+                    warning_calls = [
+                        call for call in mock_logger.warning.call_args_list
+                        if call.args and "Optional configuration keys not set" in str(call.args[0])
+                    ]
+                    self.assertEqual(len(warning_calls), 1)
+            finally:
+                setattr(logging, "_voidaccess_optional_config_warning_shown", False)
+
 
 if __name__ == "__main__":
-    unittest.main()
+    unittest.main()

{voidaccess-1.9.0 → voidaccess-1.9.1}/tests/test_llm.py

@@ -19,6 +19,19 @@ def test_select_relevant_pages_empty():
     assert result == []
 
 
+def test_get_llm_uses_runtime_provider_key_when_api_keys_omitted(monkeypatch):
+    """A key injected after module import must reach the LangChain client."""
+    from unittest.mock import patch
+    from langchain_openai import ChatOpenAI
+    from voidaccess.llm import get_llm
+
+    monkeypatch.setenv("OPENROUTER_API_KEY", "runtime-openrouter-key")
+    with patch.object(ChatOpenAI, "__init__", return_value=None) as init:
+        get_llm("openrouter/test-model")
+
+    assert init.call_args.kwargs["api_key"] == "runtime-openrouter-key"
+
+
 def test_select_relevant_pages_fits_budget():
     """Pages that fit in budget are all returned."""
     pages = [make_page("a" * 100, f"http://{i}.onion") for i in range(5)]

{voidaccess-1.9.0 → voidaccess-1.9.1}/voidaccess/config.py

@@ -2,6 +2,10 @@
 
 from importlib import import_module, reload
 
+# Reload the compatibility target so explicit `importlib.reload` calls keep
+# reflecting a test/application environment change. The warning guard itself
+# lives on the process-wide logging module, so this reload cannot reintroduce
+# warning spam.
 _config = reload(import_module("config"))
 
 for _name in dir(_config):

{voidaccess-1.9.0 → voidaccess-1.9.1}/voidaccess/llm.py

@@ -256,11 +256,32 @@ def get_llm(model_choice, api_keys: dict | None = None):
         "GOOGLE_API_KEY":     "google_api_key",
         "GROQ_API_KEY":       "groq_api_key",
     }
-    if api_keys:
-        for key_name, key_value in api_keys.items():
-            if key_value and key_name in _ENV_TO_LANGCHAIN:
-                param_name = _ENV_TO_LANGCHAIN[key_name]
-                model_specific_params[param_name] = key_value
+    # Prefer explicitly supplied per-user keys, but also resolve the current
+    # process environment when callers omit api_keys.  The CLI injects its
+    # saved config at runtime, so relying only on import-time llm_utils values
+    # silently drops a valid OPENROUTER_API_KEY.
+    runtime_keys = dict(api_keys or {})
+    base_url = str(model_specific_params.get("base_url") or "").lower()
+    if "openrouter" in base_url:
+        runtime_keys.setdefault("OPENROUTER_API_KEY", os.getenv("OPENROUTER_API_KEY", ""))
+    elif "groq.com" in base_url:
+        runtime_keys.setdefault("GROQ_API_KEY", os.getenv("GROQ_API_KEY", ""))
+    elif "ChatAnthropic" in getattr(llm_class, "__name__", ""):
+        runtime_keys.setdefault("ANTHROPIC_API_KEY", os.getenv("ANTHROPIC_API_KEY", ""))
+    elif "ChatGoogle" in getattr(llm_class, "__name__", ""):
+        runtime_keys.setdefault("GOOGLE_API_KEY", os.getenv("GOOGLE_API_KEY", ""))
+    elif "ChatOpenAI" in getattr(llm_class, "__name__", ""):
+        runtime_keys.setdefault("OPENAI_API_KEY", os.getenv("OPENAI_API_KEY", ""))
+
+    for key_name, key_value in runtime_keys.items():
+        if key_value and key_name in _ENV_TO_LANGCHAIN:
+            param_name = _ENV_TO_LANGCHAIN[key_name]
+            model_specific_params[param_name] = key_value
+            # ChatOpenAI uses `api_key` as the canonical constructor field;
+            # keep it synchronized with the mapped alias when a model config
+            # was created from stale import-time defaults.
+            if param_name == "openai_api_key":
+                model_specific_params["api_key"] = key_value
 
     # Combine common parameters with model-specific parameters
     # Model-specific parameters will override common ones if there are any conflicts

{voidaccess-1.9.0 → voidaccess-1.9.1/voidaccess.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: voidaccess
-Version: 1.9.0
+Version: 1.9.1
 Summary: Dark web OSINT CLI — automated threat intelligence from query to report
 Author: VoidAccess
 License-Expression: MIT

{voidaccess-1.9.0 → voidaccess-1.9.1}/voidaccess_cli/__init__.py

@@ -1,3 +1,3 @@
 """voidaccess CLI — dark-web OSINT command-line interface."""
 
-__version__ = "1.9.0"
+__version__ = "1.9.1"

{voidaccess-1.9.0 → voidaccess-1.9.1}/voidaccess_cli/commands/investigate.py

@@ -26,13 +26,6 @@ from typing import Any, Callable, Optional
 import typer
 from rich.console import Console
 
-from extractor.identity import entity_display_id
-
-# Import reputation enrichment sources (used in Step 6.2–6.4)
-from sources.domain_reputation import enrich_domain_entities
-from sources.email_reputation import enrich_email_entities
-from sources.hash_reputation import enrich_hash_entities
-
 console = Console()
 logger = logging.getLogger(__name__)
 
@@ -368,7 +361,11 @@ async def _run_investigation(
     if not no_llm:
         try:
             from voidaccess.llm import get_llm
-            llm = get_llm(chosen_model)
+            provider = cli_config.get_llm_provider(cfg)
+            provider_env = cli_config.PROVIDER_ENV.get(provider)
+            api_key = cli_config.get_llm_key(cfg)
+            api_keys = {provider_env: api_key} if provider_env and api_key else {}
+            llm = get_llm(chosen_model, api_keys=api_keys)
         except Exception as exc:
             display.update_step("Refining query", "fail", f"LLM init failed: {exc}")
             llm = None
@@ -716,6 +713,7 @@ async def _run_investigation(
     # whole cluster further down.
     display.update_step("Enriching domains", "active")
     try:
+        from sources.domain_reputation import enrich_domain_entities
         # enrich_*_entities return (extraction_results, stats) — unpack so the
         # threaded list isn't clobbered into a tuple for the next step.
         extraction_results, _ = await asyncio.wait_for(
@@ -738,6 +736,7 @@ async def _run_investigation(
 
     display.update_step("Enriching hashes", "active")
     try:
+        from sources.hash_reputation import enrich_hash_entities
         extraction_results, _ = await asyncio.wait_for(
             enrich_hash_entities(extraction_results, inv_uuid),
             timeout=45,
@@ -752,6 +751,7 @@ async def _run_investigation(
 
     display.update_step("Enriching emails", "active")
     try:
+        from sources.email_reputation import enrich_email_entities
         extraction_results, _ = await asyncio.wait_for(
             enrich_email_entities(extraction_results, inv_uuid),
             timeout=30,
@@ -869,9 +869,22 @@ async def _run_investigation(
         # onto the event-loop thread so Rich's live renderer remains safe.
         loop.call_soon_threadsafe(display.update_step, "Building graph", "active", label)
 
+    def _graph_metrics(metrics: dict[str, int]) -> None:
+        detail = (
+            f"entities: {metrics.get('entity_rows_loaded', 0)} | "
+            f"intra-page edges: {metrics.get('intra_page_edges', 0)} | "
+            f"cross-page edges: {metrics.get('cross_page_edges', 0)}"
+        )
+        loop.call_soon_threadsafe(display.update_step, "Building graph", "active", detail)
+
     try:
         edges_written = await asyncio.wait_for(
-            asyncio.to_thread(_build_cooccurrence_edges, investigation_id, _graph_progress),
+            asyncio.to_thread(
+                _build_cooccurrence_edges,
+                investigation_id,
+                _graph_progress,
+                _graph_metrics,
+            ),
             timeout=CLI_PHASE_TIMEOUTS["graph_build"],
         )
         if no_llm:
@@ -1272,12 +1285,19 @@ def _lookup_page_ids(urls: list[str]) -> dict[str, uuid.UUID]:
 def _build_cooccurrence_edges(
     investigation_id: str,
     progress_callback: Optional[Callable[[str], None]] = None,
+    metrics_callback: Optional[Callable[[dict[str, int]], None]] = None,
 ) -> int:
     """Generate CO_APPEARED_ON edges for entities sharing a page."""
     from db.models import Entity
     from db.session import get_session
     from sqlalchemy.orm import joinedload
-    from graph.builder import _iter_semantic_cooccurrence_pairs
+    from graph.builder import (
+        _ENTITY_TYPE_TO_NODE_TYPE,
+        _iter_semantic_cooccurrence_pairs,
+        _link_cross_page_entities,
+        _make_node_id,
+    )
+    import networkx as nx
     from voidaccess_cli.adapters.sqlite import save_relationships
 
     edges: list[dict] = []
@@ -1292,6 +1312,7 @@ def _build_cooccurrence_edges(
             .filter(Entity.investigation_id == inv_uuid)
             .all()
         )
+        entity_rows_loaded = len(rows)
         by_page: dict[uuid.UUID, list] = {}
         for ent in rows:
             page_id = getattr(ent, "page_id", None)
@@ -1316,6 +1337,31 @@ def _build_cooccurrence_edges(
                         "confidence": 0.8,
                     }
                 )
+        intra_page_edges = len(edges)
+
+        # Calculate the same cross-page bridge metric used by the graph
+        # builder, while the ORM rows are still attached to their pages. The
+        # CLI continues to persist its bounded co-occurrence set below, but
+        # the live UI now exposes all three already-computed graph metrics.
+        graph = nx.MultiDiGraph()
+        for ent in rows:
+            page_url = ent.page.url if ent.page else ""
+            node_id = _make_node_id(ent.entity_type, ent.value, page_url)
+            graph.add_node(
+                node_id,
+                node_type=_ENTITY_TYPE_TO_NODE_TYPE.get(ent.entity_type, ""),
+                confidence=float(ent.confidence or 0.0),
+                metadata={"confidence": float(ent.confidence or 0.0)},
+            )
+        cross_page_edges = _link_cross_page_entities(graph, rows, inv_uuid)
+        if metrics_callback:
+            metrics_callback(
+                {
+                    "entity_rows_loaded": entity_rows_loaded,
+                    "intra_page_edges": intra_page_edges,
+                    "cross_page_edges": cross_page_edges,
+                }
+            )
     if progress_callback:
         progress_callback("loading persisted relationships")
     written = save_relationships(investigation_id, edges)
@@ -1408,6 +1454,8 @@ def _slugify(s: str) -> str:
 
 
 def _render_markdown(payload: dict[str, Any]) -> str:
+    from extractor.identity import entity_display_id
+
     lines: list[str] = []
     lines.append(f"# Investigation: {payload['query']}")
     lines.append(

{voidaccess-1.9.0 → voidaccess-1.9.1}/voidaccess_cli/commands/show.py

@@ -184,12 +184,14 @@ def _print_path(data: dict, from_value: str, to_value: str) -> None:
 def _print_summary(data: dict) -> None:
     inv = data.get("investigation") or data
     entities = data.get("entities", [])
+    relationships = data.get("relationships", []) or []
     table = Table(title="Investigation summary")
     table.add_column("Field", style="bold")
     table.add_column("Value")
     table.add_row("Query", str(inv.get("query") or ""))
     table.add_row("Status", str(inv.get("status") or ""))
     table.add_row("Entities", str(len(entities)))
+    table.add_row("Relationships", str(len(relationships)))
     table.add_row("Created", str(inv.get("created_at") or "")[:19])
     table.add_row("Summary", (str(inv.get("summary") or "—"))[:120])
     console.print(table)

{voidaccess-1.9.0 → voidaccess-1.9.1}/voidaccess_cli/config.py

@@ -317,10 +317,11 @@ def ensure_spacy_model(model_name: str = "en_core_web_sm") -> bool:
 
 def apply_env(config: Optional[dict[str, Any]] = None) -> None:
     """
-    Push saved config into os.environ so that the existing voidaccess
-    modules (config.py, llm.py, sources/*) pick up the values at import.
+    Push saved config into os.environ before importing runtime modules.
 
-    Must be called BEFORE any voidaccess module is imported.
+    This remains the single environment-injection boundary for the CLI;
+    runtime modules must resolve environment-dependent values when they are
+    used rather than freezing them during import.
     """
     cfg = config or load_config()
 
@@ -390,4 +391,3 @@ def apply_env(config: Optional[dict[str, Any]] = None) -> None:
             os.environ.pop(key, None)
 
 
-

{voidaccess-1.9.0 → voidaccess-1.9.1}/voidaccess_cli/main.py

@@ -521,12 +521,14 @@ def main(
         console.print(f"voidaccess {__version__}")
         raise typer.Exit()
     cli_config.apply_env()
+    # Validate after the CLI has injected its runtime environment. This keeps
+    # --help/--version cold-start safe while preserving the required-key and
+    # once-per-process optional-key checks for real command invocations.
+    import config as runtime_config
+    runtime_config.validate_config()
     if not no_banner and ctx.invoked_subcommand:
         show_banner(console)
 
 
 if __name__ == "__main__":
     app()
-
-
-