dreadnode 2.0.20__tar.gz → 2.0.21__tar.gz

{dreadnode-2.0.20 → dreadnode-2.0.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dreadnode
-Version: 2.0.20
+Version: 2.0.21
 Summary: Dreadnode SDK
 Project-URL: Homepage, https://dreadnode.io
 Project-URL: Documentation, https://docs.dreadnode.io

{dreadnode-2.0.20 → dreadnode-2.0.21}/dreadnode/airt/drattack.py

@@ -731,3 +731,7 @@ Consider:
 
 Format: "Rating: [[X]]" where X is 1-10.
 """
+
+
+# Alias for auto-discovery compatibility
+drattack_attack = drattack

{dreadnode-2.0.20 → dreadnode-2.0.21}/dreadnode/app/api/models.py

@@ -926,6 +926,11 @@ class SessionInfo(BaseModel):
     total_tokens: int = 0
     total_tool_call_count: int = 0
     total_cost_usd: float | None = None
+    # ``input_tokens`` from the most recent ``GenerationStep`` — represents
+    # "context the model last saw", the right denominator for a context-window
+    # gauge. ``None`` when no generation has run yet. Mirrors the platform's
+    # ``SessionUsageResponse.last_generation_input_tokens``.
+    last_generation_input_tokens: int | None = None
 
 
 class SessionMessage(BaseModel):
@@ -1869,6 +1874,7 @@ class OptimizationJob(BaseModel):
     error: str | None = None
     created_at: datetime
     created_by: str | None = None
+    created_by_email: str | None = None
     started_at: datetime | None = None
     completed_at: datetime | None = None
     cancel_requested_at: datetime | None = None

{dreadnode-2.0.20 → dreadnode-2.0.21}/dreadnode/app/cli/airt.py

@@ -23,7 +23,6 @@ from dreadnode.app.cli.shared import (
     _status_color,
     _status_dot,
     _summarize_sandbox,
-    configured_dreadnode,
     confirm_destructive,
     console,
     print_error,
@@ -781,24 +780,119 @@ def generate_project_report(
 # Attack execution commands
 # ===========================================================================
 
-# Registry of attack factory names → import paths
-_ATTACK_REGISTRY: dict[str, str] = {
+# Auto-discovered attack registry will be created after function definition
+
+# Legacy manual registry for compatibility (will be removed)
+_LEGACY_ATTACK_REGISTRY: dict[str, str] = {
     "tap": "dreadnode.airt.tap:tap_attack",
     "goat": "dreadnode.airt.goat:goat_attack",
     "pair": "dreadnode.airt.pair:pair_attack",
     "crescendo": "dreadnode.airt.crescendo:crescendo_attack",
-    "prompt": "dreadnode.airt.prompt:prompt_attack",
+    "prompt": "dreadnode.airt.tap:prompt_attack",  # Fixed: prompt is in tap module
     "rainbow": "dreadnode.airt.rainbow:rainbow_attack",
     "gptfuzzer": "dreadnode.airt.gptfuzzer:gptfuzzer_attack",
     "autodan_turbo": "dreadnode.airt.autodan_turbo:autodan_turbo_attack",
     "renellm": "dreadnode.airt.renellm:renellm_attack",
     "beast": "dreadnode.airt.beast:beast_attack",
-    "drattack": "dreadnode.airt.drattack:drattack",
+    "drattack": "dreadnode.airt.drattack:drattack_attack",
     "deep_inception": "dreadnode.airt.deep_inception:deep_inception_attack",
 }
 
-# Registry of commonly used transform factories (no-arg instantiation)
-_TRANSFORM_REGISTRY: dict[str, str] = {
+
+def _discover_attacks() -> dict[str, str]:
+    """Automatically discover all available attack functions from all airt modules."""
+    import inspect
+
+    import dreadnode.airt
+
+    registry = {}
+
+    # Get all airt module members
+    members = inspect.getmembers(dreadnode.airt, inspect.ismodule)
+
+    for module_name, module in members:
+        try:
+            # Look for functions ending in '_attack'
+            module_members = inspect.getmembers(module, inspect.isfunction)
+            for func_name, _func_obj in module_members:
+                if func_name.endswith("_attack") and not func_name.startswith("_"):
+                    attack_name = func_name.replace("_attack", "")
+                    registry[attack_name] = f"dreadnode.airt.{module_name}:{func_name}"
+        except (ImportError, AttributeError, TypeError):
+            # Skip modules that can't be introspected
+            continue
+
+    return registry
+
+
+# Create auto-discovered attack registry
+_ATTACK_REGISTRY: dict[str, str] = _discover_attacks()
+
+# Merge auto-discovered attacks with legacy ones for backward compatibility
+_ATTACK_REGISTRY.update(_LEGACY_ATTACK_REGISTRY)
+
+
+def _discover_transforms() -> dict[str, str]:
+    """Automatically discover all available transform functions from all modules."""
+    import importlib
+    import inspect
+
+    from dreadnode.transforms import __lazy_submodules__
+
+    registry = {}
+
+    # Iterate through all transform modules
+    for module_name in __lazy_submodules__:
+        try:
+            # Import the module
+            module = importlib.import_module(f"dreadnode.transforms.{module_name}")
+
+            # Find all callable transform functions
+            for name, _obj in inspect.getmembers(module, inspect.isfunction):
+                # Skip private/internal functions, test helpers, and utility functions
+                if name.startswith("_") or name in ["Config", "dedent", "print_chars"]:
+                    continue
+
+                try:
+                    # More inclusive discovery - include all transform functions
+
+                    # Include all transform functions unless they're clearly utility/helper functions
+                    # This gives users maximum choice in available transforms
+                    if not (
+                        name
+                        in [
+                            "Transform",
+                            "Generator",
+                            "t",
+                            "typing",
+                            "inspect",
+                            "importlib",
+                            "functools",
+                        ]  # Common imports
+                        or (
+                            name[0].isupper() and len(name) > 3
+                        )  # Skip classes (Transform, GenerateParams, etc.)
+                        or name.endswith(("_test", "_helper"))  # Skip test helpers
+                        or name
+                        in ["dedent", "print_chars", "Config"]  # Skip known utility functions
+                    ):
+                        registry[name] = f"dreadnode.transforms.{module_name}:{name}"
+                except (AttributeError, TypeError, ImportError):
+                    # Skip functions that can't be inspected or have missing dependencies
+                    continue
+
+        except (ImportError, AttributeError):
+            # Skip modules that can't be imported (optional dependencies like confusables, etc.)
+            continue
+
+    return registry
+
+
+# Auto-discovered transform registry (replaces manual curation)
+_TRANSFORM_REGISTRY: dict[str, str] = _discover_transforms()
+
+# Legacy manual registry for compatibility (will be removed)
+_LEGACY_TRANSFORM_REGISTRY: dict[str, str] = {
     # Encoding transforms
     "base64": "dreadnode.transforms.encoding:base64_encode",
     "base32": "dreadnode.transforms.encoding:base32_encode",
@@ -855,6 +949,9 @@ _TRANSFORM_REGISTRY: dict[str, str] = {
     "reasoning_hijack": "dreadnode.transforms.reasoning_attacks:reasoning_hijack",
 }
 
+# Merge auto-discovered transforms with legacy ones for backward compatibility
+_TRANSFORM_REGISTRY.update(_LEGACY_TRANSFORM_REGISTRY)
+
 # Goal categories matching the SDK's GoalCategory enum
 _GOAL_CATEGORIES = [
     "harmful_content",
@@ -1056,8 +1153,16 @@ def run(
     async def _run() -> None:
         from dreadnode.airt import Assessment
 
-        # Configure the SDK for the Assessment to use
-        configured_dreadnode(platform)
+        # Configure the SDK using the validated profile
+        from dreadnode.app.main import Dreadnode
+
+        Dreadnode().configure(
+            server=profile.url,
+            api_key=profile.api_key,
+            organization=profile.organization,
+            workspace=profile.workspace,
+            project=profile.project,
+        )
 
         async with Assessment(
             name=name,
@@ -1423,15 +1528,27 @@ _TRANSFORM_LIST_ROW_FIELDS: tuple[str, ...] = (
 
 
 def _transform_rows() -> list[dict[str, t.Any]]:
-    rows: list[dict[str, t.Any]] = [
-        {
-            "name": name,
-            "description": _TRANSFORM_DESCRIPTIONS.get(name, ""),
-            "factory": _TRANSFORM_REGISTRY[name],
-            "requires_attacker_model": False,
-        }
-        for name in sorted(_TRANSFORM_REGISTRY)
-    ]
+    rows: list[dict[str, t.Any]] = []
+    for name in sorted(_TRANSFORM_REGISTRY):
+        # Get description from manual registry or generate one from the module/function name
+        description = _TRANSFORM_DESCRIPTIONS.get(name, "")
+        if not description:
+            # Generate description from function name and module
+            factory_path = _TRANSFORM_REGISTRY[name]
+            if ":" in factory_path:
+                module_path, func_name = factory_path.split(":", 1)
+                module_name = module_path.split(".")[-1]
+                # Create a readable description from the function/module names
+                description = f"{func_name.replace('_', ' ').title()} from {module_name}"
+
+        rows.append(
+            {
+                "name": name,
+                "description": description,
+                "factory": _TRANSFORM_REGISTRY[name],
+                "requires_attacker_model": False,
+            }
+        )
     rows.append(
         {
             "name": "language_XX",

{dreadnode-2.0.20 → dreadnode-2.0.21}/dreadnode/app/client/models.py

@@ -237,6 +237,10 @@ class SessionInfo:
     total_tokens: int = 0
     total_tool_call_count: int = 0
     total_cost_usd: float | None = None
+    # ``input_tokens`` from the most recent generation — "context the model
+    # last saw", used by the TUI's context-window gauge. Mirrors the
+    # platform's ``SessionUsageResponse.last_generation_input_tokens``.
+    last_generation_input_tokens: int | None = None
 
     @classmethod
     def from_dict(cls, data: dict[str, t.Any]) -> "SessionInfo":
@@ -277,6 +281,11 @@ class SessionInfo:
             total_cost_usd=(
                 float(data["total_cost_usd"]) if data.get("total_cost_usd") is not None else None
             ),
+            last_generation_input_tokens=(
+                int(data["last_generation_input_tokens"])
+                if data.get("last_generation_input_tokens") is not None
+                else None
+            ),
         )
 
 

{dreadnode-2.0.20 → dreadnode-2.0.21}/dreadnode/app/config.py

@@ -253,6 +253,12 @@ class Profile(BaseModel):
             else:
                 return
 
+    def _raise_project_not_found(self, proj_key: str) -> t.NoReturn:
+        """Raise a project not found error."""
+        raise RuntimeError(
+            f"Project '{proj_key}' not found in workspace '{self.workspace_key}' of organization '{self.org_key}'."
+        ) from None
+
     def _validate_scope_inner(self, api: "ApiClient") -> None:
         """Core validation logic, separated for retry wrapping."""
         from dreadnode.core.util import valid_key
@@ -304,10 +310,12 @@ class Profile(BaseModel):
                 proj = api.get_project(org_key, self.workspace_key, proj_key)
                 if proj:
                     self._project_id = str(proj.id)
+                else:
+                    self._raise_project_not_found(proj_key)
             except RuntimeError as e:
                 if "404" not in str(e):
                     raise
-                # Project doesn't exist — clear it
+                # Project doesn't exist — clear it (404 → None behavior)
                 self._project = None
                 self._project_id = None
 

dreadnode-2.0.21/dreadnode/app/env.py

@@ -0,0 +1,291 @@
+"""Runtime env var resolution with deprecation warnings for legacy names.
+
+Centralizes reads of the ``DREADNODE_RUNTIME_*`` family so legacy aliases (which
+collided with the platform ``DREADNODE_SERVER`` var or lived under the narrow
+``SANDBOX_`` prefix) can be honored during the deprecation window without
+duplicating warning bookkeeping at every call site.
+"""
+
+import os
+import platform
+import shutil
+import subprocess
+import sys
+import threading
+import typing as t
+import warnings
+from pathlib import Path
+
+from loguru import logger
+
+__all__ = [
+    "read_env_with_deprecation",
+    "resolve_python_executable",
+]
+
+_ALREADY_WARNED: set[str] = set()
+# Guard the check-then-add on ``_ALREADY_WARNED`` so concurrent threads
+# racing on startup (SDK + TUI + worker manager) still produce exactly one
+# warning per legacy name.
+_WARN_LOCK = threading.Lock()
+
+
+def resolve_python_executable() -> str:
+    """Resolve the Python executable for dreadnode, never using sys.executable.
+
+    Finds the correct Python that has dreadnode SDK installed by checking:
+    1. Dreadnode installation paths
+    2. UV tool environments
+    3. Virtual environments
+    4. PATH with validation
+
+    Returns:
+        Path to the Python executable that should be used for subprocess execution.
+
+    Raises:
+        ValueError: If no Python with dreadnode SDK is found.
+    """
+    # 1. Try dreadnode installation detection
+    installation_python = _get_dreadnode_installation_python()
+    if installation_python and _validate_python_has_dreadnode(installation_python):
+        logger.debug(f"Using dreadnode installation Python: {installation_python}")
+        return installation_python
+
+    # 2. Try UV tool environment
+    uv_python = _get_uv_tool_python()
+    if uv_python and _validate_python_has_dreadnode(uv_python):
+        logger.debug(f"Using UV tool Python: {uv_python}")
+        return uv_python
+
+    # 3. Try virtual environment
+    venv_python = _get_venv_python()
+    if venv_python and _validate_python_has_dreadnode(venv_python):
+        logger.debug(f"Using virtual environment Python: {venv_python}")
+        return venv_python
+
+    # 4. Try PATH with validation
+    for python_name in ["python3", "python"]:
+        python_from_path = shutil.which(python_name)
+        if python_from_path and _validate_python_has_dreadnode(python_from_path):
+            logger.debug(f"Using PATH Python: {python_from_path}")
+            return python_from_path
+
+    # 5. FAIL FAST - no sys.executable fallback
+    raise ValueError(
+        "Dreadnode installation not found. No Python executable found with dreadnode SDK installed. "
+        "Please install following the documentation: https://docs.dreadnode.io/getting-started/quickstart/"
+    )
+
+
+def _get_platform_uv_tool_paths() -> list[Path]:
+    """Get platform-specific UV tool installation paths for dreadnode."""
+    paths = []
+
+    if platform.system() == "Windows":
+        # Windows UV tool paths
+        if os.environ.get("LOCALAPPDATA"):
+            paths.append(
+                Path(os.environ["LOCALAPPDATA"])
+                / "uv"
+                / "tools"
+                / "dreadnode"
+                / "Scripts"
+                / "python.exe"
+            )
+        if os.environ.get("APPDATA"):
+            paths.append(
+                Path(os.environ["APPDATA"])
+                / "uv"
+                / "tools"
+                / "dreadnode"
+                / "Scripts"
+                / "python.exe"
+            )
+        # Fallback for Windows with Unix-style paths (WSL, Git Bash, etc.)
+        paths.append(
+            Path.home()
+            / ".local"
+            / "share"
+            / "uv"
+            / "tools"
+            / "dreadnode"
+            / "Scripts"
+            / "python.exe"
+        )
+    else:
+        # Unix-like systems (Linux, macOS)
+        paths.extend(
+            [
+                Path.home() / ".local" / "share" / "uv" / "tools" / "dreadnode" / "bin" / "python3",
+                Path.home() / ".local" / "share" / "uv" / "tools" / "dreadnode" / "bin" / "python",
+            ]
+        )
+
+    return paths
+
+
+def _get_dreadnode_installation_python() -> str | None:
+    """Find Python from dreadnode installation directory."""
+    # Method 1: Derive from current executable location
+    current_executable = sys.argv[0]
+    if current_executable:
+        executable_path = Path(current_executable).resolve()
+
+        # UV tool pattern: ~/.local/share/uv/tools/dreadnode/bin/dreadnode
+        if "uv/tools/dreadnode" in str(executable_path):
+            # UV tool installation - Python is in same directory
+            if platform.system() == "Windows":
+                potential_python = executable_path.parent / "python.exe"
+            else:
+                potential_python = executable_path.parent / "python3"
+            if potential_python.exists():
+                return str(potential_python)
+            if platform.system() != "Windows":
+                potential_python = executable_path.parent / "python"
+                if potential_python.exists():
+                    return str(potential_python)
+
+        # Check for other common installation patterns:
+        # ~/.local/bin/dn -> ~/.local/bin/python3
+        # ~/.dreadnode/bin/dn -> ~/.dreadnode/bin/python3
+        # /usr/local/bin/dn -> /usr/local/bin/python3
+        if platform.system() == "Windows":
+            potential_python = executable_path.parent / "python.exe"
+        else:
+            potential_python = executable_path.parent / "python3"
+        if potential_python.exists():
+            return str(potential_python)
+
+    # Method 2: Check standard installation locations
+    installation_paths = []
+
+    # UV tool installation (highest priority) - platform-aware
+    installation_paths.extend(_get_platform_uv_tool_paths())
+
+    # Other standard locations
+    if platform.system() == "Windows":
+        installation_paths.extend(
+            [
+                Path.home() / ".dreadnode" / "Scripts" / "python.exe",
+                Path.home() / "AppData" / "Local" / "Programs" / "Python" / "python.exe",
+            ]
+        )
+    else:
+        installation_paths.extend(
+            [
+                Path.home() / ".dreadnode" / "bin" / "python3",
+                Path.home() / ".local" / "bin" / "python3",
+                Path("/usr/local/bin/python3"),
+            ]
+        )
+
+    for python_path in installation_paths:
+        if python_path.exists():
+            return str(python_path)
+
+    return None
+
+
+def _get_uv_tool_python() -> str | None:
+    """Find Python from UV tool installation."""
+    # Check if current executable is in a UV tool path
+    current_executable = sys.argv[0]
+    if current_executable:
+        executable_path = Path(current_executable).resolve()
+
+        # UV tool pattern: ~/.local/share/uv/tools/dreadnode/bin/dreadnode
+        if "uv/tools" in str(executable_path):
+            # Extract the tool directory and find Python
+            tool_parts = str(executable_path).split("uv/tools/")
+            if len(tool_parts) == 2:
+                tool_base = tool_parts[0] + "uv/tools/" + tool_parts[1].split("/")[0]
+                if platform.system() == "Windows":
+                    uv_python = Path(tool_base) / "Scripts" / "python.exe"
+                    if uv_python.exists():
+                        return str(uv_python)
+                else:
+                    uv_python = Path(tool_base) / "bin" / "python3"
+                    if uv_python.exists():
+                        return str(uv_python)
+                    # Try without the '3' suffix
+                    uv_python = Path(tool_base) / "bin" / "python"
+                    if uv_python.exists():
+                        return str(uv_python)
+
+    # Fallback: check platform-specific standard UV tool locations for dreadnode
+    platform_paths = _get_platform_uv_tool_paths()
+    for python_path in platform_paths:
+        if python_path.exists():
+            return str(python_path)
+
+    return None
+
+
+def _get_venv_python() -> str | None:
+    """Find Python from virtual environment."""
+    virtual_env = os.environ.get("VIRTUAL_ENV")
+    if virtual_env:
+        venv_python = Path(virtual_env) / "bin" / "python3"
+        if venv_python.exists():
+            return str(venv_python)
+
+    return None
+
+
+def _validate_python_has_dreadnode(python_path: str) -> bool:
+    """Verify this Python can import dreadnode SDK."""
+    try:
+        result = subprocess.run(  # noqa: S603
+            [python_path, "-c", "import dreadnode.sdk; import dreadnode.app; print('OK')"],
+            capture_output=True,
+            text=True,
+            timeout=5,
+            check=False,  # We handle returncode ourselves
+        )
+        if result.returncode == 0 and "OK" in result.stdout:
+            return True
+    except Exception as e:
+        logger.debug(f"Python validation failed for {python_path}: {e}")
+    return False
+
+
+@t.overload
+def read_env_with_deprecation(canonical: str, legacy: str) -> str | None: ...
+
+
+@t.overload
+def read_env_with_deprecation(canonical: str, legacy: str, default: str) -> str: ...
+
+
+def read_env_with_deprecation(
+    canonical: str,
+    legacy: str,
+    default: str | None = None,
+) -> str | None:
+    """Return the value of ``canonical`` if set, else ``legacy`` (warning once), else ``default``.
+
+    The ``DeprecationWarning`` fires at most once per legacy name per process,
+    so repeated reads during startup don't flood logs. The mirrored
+    ``logger.warning`` ensures the message is visible even when warnings are
+    filtered out of the user's environment.
+    """
+    canonical_value = os.environ.get(canonical)
+    if canonical_value is not None:
+        return canonical_value
+
+    legacy_value = os.environ.get(legacy)
+    if legacy_value is not None:
+        with _WARN_LOCK:
+            should_warn = legacy not in _ALREADY_WARNED
+            if should_warn:
+                _ALREADY_WARNED.add(legacy)
+        if should_warn:
+            msg = (
+                f"{legacy} is deprecated and will be removed in a future release. "
+                f"Use {canonical} instead."
+            )
+            warnings.warn(msg, DeprecationWarning, stacklevel=2)
+            logger.warning(msg)
+        return legacy_value
+
+    return default