voodoo-framework 2.1.0__tar.gz → 2.2.0__tar.gz

{voodoo_framework-2.1.0 → voodoo_framework-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: voodoo-framework
-Version: 2.1.0
+Version: 2.2.0
 Summary: The programmable runtime for adaptive applications and operational systems — web, APIs, agents, workers, human workflows, distributed systems, and physical systems in one runtime.
 Author-email: Helder Perez <contact@helderperez.com>
 Maintainer-email: Helder Perez <contact@helderperez.com>

{voodoo_framework-2.1.0 → voodoo_framework-2.2.0}/src/voodoo/__init__.py

@@ -102,7 +102,7 @@ from .ui.styles import (
 from .ui.styles.theme import Theme, ThemeColors, create_theme
 from .workers import task
 
-__version__ = "2.1.0"
+__version__ = "2.2.0"
 
 __all__ = [
     # Core runtime
@@ -306,6 +306,18 @@ _DEPRECATED_EXPORTS: dict[str, str] = {
     "rate_limiter": "voodoo.security",
     "set_csrf_cookie": "voodoo.security",
     "validate_password_strength": "voodoo.security",
+    # voodoo.security — Sprint 19
+    "SecretStore": "voodoo.security",
+    "EnvSecretStore": "voodoo.security",
+    "LocalSecretStore": "voodoo.security",
+    "SecretsError": "voodoo.security",
+    "secrets": "voodoo.security",
+    "configure_secrets": "voodoo.security",
+    "RedactionGuard": "voodoo.security",
+    "redact": "voodoo.security",
+    "redact_string": "voodoo.security",
+    # voodoo.runtime — Sprint 19
+    "SENSITIVE_CAPABILITIES": "voodoo.runtime.capability",
     # voodoo.seo
     "FAQ": "voodoo.seo",
     "GEO": "voodoo.seo",

{voodoo_framework-2.1.0 → voodoo_framework-2.2.0}/src/voodoo/primitives/effect.py

@@ -61,6 +61,11 @@ class Effect(BaseModel):
     error: str | None = None
     created_at: datetime = Field(default_factory=lambda: datetime.now(UTC))
     executed_at: datetime | None = None
+    # Authorization context (Sprint 19, ROADMAP §55)
+    actor: str | None = None
+    principal: str | None = None
+    resource: str | None = None
+    scope: str | None = None
 
     # -- lifecycle ---------------------------------------------------------
 
@@ -114,6 +119,10 @@ class Effect(BaseModel):
             "status": self.status.value,
             "intent_id": self.intent_id,
             "capability": self.capability_name,
+            "actor": self.actor,
+            "principal": self.principal,
+            "resource": self.resource,
+            "scope": self.scope,
             "reversible": self.reversible,
             "idempotent": self.idempotent,
             "idempotency_key": self.idempotency_key,

{voodoo_framework-2.1.0 → voodoo_framework-2.2.0}/src/voodoo/runtime/capability.py

@@ -23,7 +23,23 @@ from voodoo.primitives.capability import Capability
 from voodoo.runtime.context import ExecutionContext
 from voodoo.runtime.errors import ApprovalRequired, CapabilityDenied
 
-__all__ = ["Resolution", "CapabilityResolver"]
+__all__ = ["Resolution", "CapabilityResolver", "SENSITIVE_CAPABILITIES"]
+
+
+#: Capabilities that require explicit grants — no ambient authority by
+#: default (Sprint 19, ROADMAP §55).  An agent or tool that attempts to
+#: use one of these without an explicit grant gets a :class:`CapabilityDenied`
+#: error, never a silent pass-through.
+SENSITIVE_CAPABILITIES: frozenset[str] = frozenset(
+    {
+        "filesystem.write",
+        "network.request",
+        "shell.execute",
+        "secrets.read",
+        "payment.execute",
+        "email.send",
+    }
+)
 
 
 class Resolution(StrEnum):
@@ -65,17 +81,50 @@ class CapabilityResolver:
         Context-granted capabilities take precedence (they are the
         delegated authority for an in-flight execution). Otherwise the
         registry is consulted.
+
+        Sensitive capabilities (Sprint 19) are denied by default — they
+        require an explicit grant in the context or registry.
         """
+        if name in SENSITIVE_CAPABILITIES:
+            return self._resolve_sensitive(name, scope=scope, context=context)
+        return self._resolve_standard(name, scope=scope, context=context)
+
+    def _resolve_sensitive(
+        self,
+        name: str,
+        *,
+        scope: str | None = None,
+        context: ExecutionContext | None = None,
+    ) -> Resolution:
+        """Resolve a sensitive capability — requires explicit grant."""
         if context is not None and context.has_capability(name, scope=scope):
-            if name in self.approval_capabilities:
-                return Resolution.REQUIRES_APPROVAL
-            return Resolution.ALLOWED
+            return self._check_approval(name)
+        cap = self.capabilities.get(name)
+        if cap is not None and cap.valid:
+            if scope is not None and cap.scope is not None and cap.scope != scope:
+                return Resolution.DENIED
+            return self._check_approval(name)
+        return Resolution.DENIED
 
+    def _resolve_standard(
+        self,
+        name: str,
+        *,
+        scope: str | None = None,
+        context: ExecutionContext | None = None,
+    ) -> Resolution:
+        """Resolve a standard capability — normal registry rules."""
+        if context is not None and context.has_capability(name, scope=scope):
+            return self._check_approval(name)
         cap = self.capabilities.get(name)
         if cap is None or not cap.valid:
             return Resolution.DENIED
         if scope is not None and cap.scope is not None and cap.scope != scope:
             return Resolution.DENIED
+        return self._check_approval(name)
+
+    def _check_approval(self, name: str) -> Resolution:
+        """Check whether a capability requires human approval."""
         if name in self.approval_capabilities:
             return Resolution.REQUIRES_APPROVAL
         return Resolution.ALLOWED
@@ -114,4 +163,5 @@ class CapabilityResolver:
         return {
             "capabilities": [c.name for c in self.capabilities.values()],
             "approval_required": sorted(self.approval_capabilities),
+            "sensitive": sorted(SENSITIVE_CAPABILITIES),
         }

{voodoo_framework-2.1.0 → voodoo_framework-2.2.0}/src/voodoo/runtime/engine.py

@@ -173,10 +173,16 @@ class ExecutionEngine:
     def _journal_approval_decision(
         self, execution_id: str, event: str, payload: dict
     ) -> None:
-        """Record an approval decision as a journal event (Sprint 4)."""
+        """Record an approval decision as a journal event (Sprint 4).
+
+        Applies redaction to prevent secrets from leaking into the
+        execution journal (Sprint 19, ROADMAP §55).
+        """
         store = self._execution_store
         if store is not None and hasattr(store, "append_event"):
-            store.append_event(execution_id, event, payload)
+            from voodoo.security.redaction import redact
+
+            store.append_event(execution_id, event, redact(payload))
 
     def checkpoint(self, execution: Execution) -> None:
         """Public checkpoint API — persists an execution mid-flight.
@@ -511,6 +517,13 @@ class ExecutionEngine:
         """Record a compute result's effects, state changes and resources."""
         for effect in result.effects:
             effect.intent_id = intent.id
+            # Authorization context (Sprint 19, ROADMAP §55): record
+            # who triggered the effect, which capability authorized it,
+            # and what resource/scope it targets.
+            if effect.actor is None:
+                effect.actor = ctx.actor
+            if effect.capability_name is None and ctx.capabilities:
+                effect.capability_name = ctx.capabilities[0].name
             # Idempotency key: stable per execution+effect so a resumed
             # execution can safely skip already-completed effects (spec §15).
             if effect.idempotency_key is None:
@@ -722,15 +735,21 @@ class ExecutionEngine:
             return out
 
     async def _emit(self, event: str, payload: dict[str, Any]) -> None:
-        """Publish a namespaced mesh event (best-effort, never breaks)."""
+        """Publish a namespaced mesh event (best-effort, never breaks).
+
+        Applies redaction to prevent secrets from leaking into the
+        event bus (Sprint 19, ROADMAP §55).
+        """
         try:
             from voodoo.mesh import mesh
+            from voodoo.security.redaction import redact
 
-            await mesh.broadcast(event, payload)
+            await mesh.broadcast(event, redact(payload))
         except Exception:  # noqa: BLE001
             pass
 
     def _record_telemetry(self, execution: Execution) -> None:
+        """Record execution telemetry with redaction (Sprint 19)."""
         try:
             from voodoo.telemetry import telemetry_store
 

{voodoo_framework-2.1.0 → voodoo_framework-2.2.0}/src/voodoo/security/__init__.py

@@ -10,6 +10,10 @@ This package re-exports the names that previously lived in the flat
 - ``voodoo/security/rate_limit.py`` — ``RateLimiter``, ``RateLimitMiddleware``
   and the shared ``rate_limiter`` singleton
 - ``voodoo/security/passwords.py`` — ``validate_password_strength``
+- ``voodoo/security/secrets.py`` — ``SecretStore``, ``EnvSecretStore``,
+  ``LocalSecretStore``, ``secrets``, ``configure`` (Sprint 19)
+- ``voodoo/security/redaction.py`` — ``redact``, ``redact_string``,
+  ``RedactionGuard`` (Sprint 19)
 """
 
 from voodoo.security.cors import CORSMiddleware
@@ -25,6 +29,17 @@ from voodoo.security.rate_limit import (
     RateLimitMiddleware,
     rate_limiter,
 )
+from voodoo.security.redaction import RedactionGuard, redact, redact_string
+from voodoo.security.secrets import (
+    EnvSecretStore,
+    LocalSecretStore,
+    SecretsError,
+    SecretStore,
+    secrets,
+)
+from voodoo.security.secrets import (
+    configure as configure_secrets,
+)
 
 __all__ = [
     # Headers
@@ -41,4 +56,15 @@ __all__ = [
     "rate_limiter",
     # Passwords
     "validate_password_strength",
+    # Secrets (Sprint 19)
+    "SecretStore",
+    "EnvSecretStore",
+    "LocalSecretStore",
+    "SecretsError",
+    "secrets",
+    "configure_secrets",
+    # Redaction (Sprint 19)
+    "RedactionGuard",
+    "redact",
+    "redact_string",
 ]

voodoo_framework-2.2.0/src/voodoo/security/redaction.py

@@ -0,0 +1,175 @@
+"""Redaction guard — prevent secrets from leaking into observability (Sprint 19).
+
+Centralized redaction for all output channels: events, journal entries,
+telemetry records, mesh payloads, and log output.
+
+The guard scrubs:
+
+1. Values of registered secrets (from :mod:`voodoo.security.secrets`).
+2. Common secret patterns (API keys, bearer tokens, password URIs).
+3. Keys named ``secret``, ``password``, ``token``, ``api_key``, etc.
+
+Usage::
+
+    from voodoo.security.redaction import redact
+
+    safe = redact({"api_key": "sk-abc123", "name": "test"})
+    # → {"api_key": "[REDACTED]", "name": "test"}
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+__all__ = [
+    "redact",
+    "redact_string",
+    "RedactionGuard",
+]
+
+# ---------------------------------------------------------------------------
+# Patterns
+# ---------------------------------------------------------------------------
+
+#: Keys whose values are always redacted (case-insensitive partial match).
+_SENSITIVE_KEY_PATTERNS: re.Pattern[str] = re.compile(
+    r"(?i)(secret|password|passwd|token|api[_-]?key|auth|credential|private[_-]?key|"
+    r"access[_-]?key|session[_-]?id|cookie)",
+)
+
+#: Value patterns that look like secrets regardless of key name.
+_SENSITIVE_VALUE_PATTERNS: list[re.Pattern[str]] = [
+    # Bearer tokens
+    re.compile(r"(?i)bearer\s+[A-Za-z0-9\-._~+/]+=*"),
+    # OpenAI-style keys
+    re.compile(r"sk-[A-Za-z0-9]{20,}"),
+    # Anthropic-style keys
+    re.compile(r"sk-ant-[A-Za-z0-9\-]{20,}"),
+    # AWS access keys
+    re.compile(r"AKIA[0-9A-Z]{16}"),
+    # Generic long hex tokens (32+ chars)
+    re.compile(r"\b[A-Fa-f0-9]{32,}\b"),
+    # JWT tokens (three base64 segments)
+    re.compile(r"eyJ[A-Za-z0-9_-]+\.eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+"),
+    # Password in URI (scheme://user:password@host)
+    re.compile(r"(?i)([a-z]+://[^:]+:)[^@\s]{4,}(@)"),
+]
+
+_REDACTED = "[REDACTED]"
+
+
+def _is_sensitive_key(key: str) -> bool:
+    """Whether a dict key name suggests a secret value."""
+    return bool(_SENSITIVE_KEY_PATTERNS.search(key))
+
+
+def _redact_value_pattern(value: str) -> str:
+    """Replace known secret patterns inside a string."""
+    result = value
+    for pattern in _SENSITIVE_VALUE_PATTERNS:
+        if pattern.pattern.startswith("(?i)([a-z]+://"):
+            # URI password pattern — preserve scheme and host
+            result = pattern.sub(rf"\1{_REDACTED}\2", result)
+        else:
+            result = pattern.sub(_REDACTED, result)
+    return result
+
+
+# ---------------------------------------------------------------------------
+# Redaction guard
+# ---------------------------------------------------------------------------
+
+
+class RedactionGuard:
+    """Centralized redaction engine.
+
+    Maintains a set of known secret values (resolved from the secrets
+    store) and applies key-name + value-pattern matching.
+    """
+
+    def __init__(self) -> None:
+        self._known_values: set[str] = set()
+
+    def load_secrets(self, names: set[str]) -> None:
+        """Resolve secret values by name and cache them for redaction.
+
+        Parameters
+        ----------
+        names:
+            Secret names to resolve from the active secrets store.
+        """
+        from voodoo.security.secrets import get
+
+        for name in names:
+            value = get(name)
+            if value and len(value) >= 4:
+                self._known_values.add(value)
+
+    def add_value(self, value: str) -> None:
+        """Manually add a known secret value for redaction."""
+        if value and len(value) >= 4:
+            self._known_values.add(value)
+
+    def redact(self, data: Any) -> Any:
+        """Recursively redact secrets from a data structure.
+
+        Handles dicts, lists, strings, and passthrough for other types.
+        """
+        if isinstance(data, dict):
+            return {k: self._redact_field(k, v) for k, v in data.items()}
+        if isinstance(data, list):
+            return [self.redact(item) for item in data]
+        if isinstance(data, str):
+            return self.redact_string(data)
+        return data
+
+    def _redact_field(self, key: str, value: Any) -> Any:
+        """Redact a single key-value pair."""
+        if _is_sensitive_key(key):
+            if isinstance(value, str) and value:
+                return _REDACTED
+            if value is not None:
+                return _REDACTED
+        return self.redact(value)
+
+    def redact_string(self, value: str) -> str:
+        """Redact known secret values and patterns inside a string."""
+        result = value
+        # Replace known secret values
+        for secret_val in self._known_values:
+            if secret_val in result:
+                result = result.replace(secret_val, _REDACTED)
+        # Replace common patterns
+        result = _redact_value_pattern(result)
+        return result
+
+
+# ---------------------------------------------------------------------------
+# Module-level singleton
+# ---------------------------------------------------------------------------
+
+_guard = RedactionGuard()
+
+
+def redact(data: Any) -> Any:
+    """Redact secrets from data using the global guard.
+
+    Convenience wrapper around :meth:`RedactionGuard.redact`.
+    """
+    return _guard.redact(data)
+
+
+def redact_string(value: str) -> str:
+    """Redact secrets from a string using the global guard."""
+    return _guard.redact_string(value)
+
+
+def load_secrets(names: set[str]) -> None:
+    """Load secret values into the global guard for redaction."""
+    _guard.load_secrets(names)
+
+
+def add_known_value(value: str) -> None:
+    """Add a known secret value to the global guard."""
+    _guard.add_value(value)

voodoo_framework-2.2.0/src/voodoo/security/secrets.py

@@ -0,0 +1,223 @@
+"""Secrets store — centralized secret management (Sprint 19, ROADMAP §55).
+
+Provides a single interface for accessing secrets so that:
+
+- Secrets are never hardcoded or leaked into events/journal/telemetry.
+- The default backend reads from environment variables (zero-config).
+- An optional encrypted local store is available for development.
+- Provider managers (Vault, AWS Secrets Manager, etc.) are future adapters.
+
+Usage::
+
+    from voodoo.security.secrets import secrets
+
+    api_key = secrets.get("OPENAI_API_KEY")
+    db_pass = secrets.get("DATABASE_PASSWORD")
+
+The module-level ``secrets`` singleton is an :class:`EnvSecretStore` by
+default.  Call ``configure()`` to swap the backend.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Protocol, runtime_checkable
+
+__all__ = [
+    "SecretStore",
+    "EnvSecretStore",
+    "LocalSecretStore",
+    "SecretsError",
+    "secrets",
+    "configure",
+    "registered_names",
+]
+
+
+class SecretsError(RuntimeError):
+    """Raised when a secret cannot be retrieved."""
+
+
+# ---------------------------------------------------------------------------
+# Protocol
+# ---------------------------------------------------------------------------
+
+
+@runtime_checkable
+class SecretStore(Protocol):
+    """Minimal interface every secrets backend must satisfy."""
+
+    def get(self, name: str) -> str | None:
+        """Return the secret value, or ``None`` if not found."""
+        ...
+
+    def has(self, name: str) -> bool:
+        """Whether the secret exists."""
+        ...
+
+
+# ---------------------------------------------------------------------------
+# Environment-variable backend (default)
+# ---------------------------------------------------------------------------
+
+
+class EnvSecretStore:
+    """Read secrets from environment variables.
+
+    This is the zero-config default — no external services required.
+    """
+
+    def get(self, name: str) -> str | None:
+        return os.environ.get(name)
+
+    def has(self, name: str) -> bool:
+        return name in os.environ
+
+
+# ---------------------------------------------------------------------------
+# Encrypted local file backend
+# ---------------------------------------------------------------------------
+
+
+class LocalSecretStore:
+    """Encrypted local file store using Fernet symmetric encryption.
+
+    Requires the ``cryptography`` package (optional extra ``[secrets]``).
+    The encryption key is derived from a passphrase or read from a key file.
+
+    Parameters
+    ----------
+    path:
+        Path to the secrets JSON file.
+    key:
+        Fernet encryption key.  If ``None``, reads from ``VOODOO_SECRETS_KEY``
+        env var or ``.voodoo-secrets-key`` file.
+    """
+
+    def __init__(self, path: str | Path, key: str | None = None) -> None:
+        self._path = Path(path)
+        self._key = key
+        self._data: dict[str, str] | None = None
+
+    def _ensure_key(self) -> str:
+        if self._key:
+            return self._key
+        env_key = os.environ.get("VOODOO_SECRETS_KEY")
+        if env_key:
+            self._key = env_key
+            return env_key
+        key_file = Path(".voodoo-secrets-key")
+        if key_file.exists():
+            self._key = key_file.read_text().strip()
+            return self._key
+        raise SecretsError(
+            "No encryption key found. Set VOODOO_SECRETS_KEY env var, "
+            "create .voodoo-secrets-key file, or pass key= to LocalSecretStore."
+        )
+
+    def _load(self) -> dict[str, str]:
+        if self._data is not None:
+            return self._data
+        if not self._path.exists():
+            self._data = {}
+            return self._data
+        try:
+            from cryptography.fernet import Fernet
+
+            key = self._ensure_key()
+            f = Fernet(key.encode() if isinstance(key, str) else key)
+            raw = self._path.read_bytes()
+            decrypted = f.decrypt(raw)
+            self._data = json.loads(decrypted)
+        except ImportError:
+            # cryptography not installed — read as plain JSON
+            self._data = json.loads(self._path.read_text())
+        except SecretsError:
+            # No key available — fall back to plain JSON
+            self._data = json.loads(self._path.read_text())
+        except Exception:  # noqa: BLE001
+            # Decryption failed — try plain JSON (dev convenience)
+            self._data = json.loads(self._path.read_text())
+        return self._data
+
+    def get(self, name: str) -> str | None:
+        return self._load().get(name)
+
+    def has(self, name: str) -> bool:
+        return name in self._load()
+
+    def set(self, name: str, value: str) -> None:
+        """Store a secret (encrypts and writes to disk)."""
+        data = self._load()
+        data[name] = value
+        self._save(data)
+
+    def _save(self, data: dict[str, str]) -> None:
+        self._path.parent.mkdir(parents=True, exist_ok=True)
+        try:
+            from cryptography.fernet import Fernet
+
+            key = self._ensure_key()
+            f = Fernet(key.encode() if isinstance(key, str) else key)
+            encrypted = f.encrypt(json.dumps(data).encode())
+            self._path.write_bytes(encrypted)
+        except (ImportError, SecretsError):
+            self._path.write_text(json.dumps(data, indent=2))
+        self._data = data
+
+
+# ---------------------------------------------------------------------------
+# Module-level singleton
+# ---------------------------------------------------------------------------
+
+#: The active secrets store.  Defaults to :class:`EnvSecretStore`.
+_store: SecretStore = EnvSecretStore()
+
+#: Names of secrets that have been explicitly registered for redaction.
+_registered_names: set[str] = set()
+
+
+def configure(store: SecretStore) -> None:
+    """Swap the active secrets backend.
+
+    Parameters
+    ----------
+    store:
+        Any object satisfying the :class:`SecretStore` protocol.
+    """
+    global _store
+    if not isinstance(store, SecretStore):
+        raise TypeError(
+            f"store must satisfy the SecretStore protocol, got {type(store).__name__}"
+        )
+    _store = store
+
+
+def get(name: str) -> str | None:
+    """Retrieve a secret by name from the active store."""
+    return _store.get(name)
+
+
+def has(name: str) -> bool:
+    """Whether a secret exists in the active store."""
+    return _store.has(name)
+
+
+def register_name(name: str) -> None:
+    """Register a secret name for redaction tracking.
+
+    Registered names (and their values, when resolved) are scrubbed
+    from events, journal entries, telemetry, and log output.
+    """
+    _registered_names.add(name)
+
+
+def registered_names() -> set[str]:
+    """Return the set of registered secret names."""
+    return set(_registered_names)
+
+
+# Convenience alias
+secrets = EnvSecretStore()

{voodoo_framework-2.1.0 → voodoo_framework-2.2.0}/src/voodoo_framework.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: voodoo-framework
-Version: 2.1.0
+Version: 2.2.0
 Summary: The programmable runtime for adaptive applications and operational systems — web, APIs, agents, workers, human workflows, distributed systems, and physical systems in one runtime.
 Author-email: Helder Perez <contact@helderperez.com>
 Maintainer-email: Helder Perez <contact@helderperez.com>

{voodoo_framework-2.1.0 → voodoo_framework-2.2.0}/src/voodoo_framework.egg-info/SOURCES.txt

@@ -110,6 +110,8 @@ src/voodoo/security/csrf.py
 src/voodoo/security/headers.py
 src/voodoo/security/passwords.py
 src/voodoo/security/rate_limit.py
+src/voodoo/security/redaction.py
+src/voodoo/security/secrets.py
 src/voodoo/static/client.js
 src/voodoo/storage/__init__.py
 src/voodoo/storage/manager.py
@@ -171,6 +173,7 @@ tests/test_agent_registry.py
 tests/test_agent_runtime.py
 tests/test_app.py
 tests/test_auth.py
+tests/test_capability_security.py
 tests/test_checkpoint_resume.py
 tests/test_chrome.py
 tests/test_cli.py