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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: voodoo-framework
-Version: 2.0.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>
@@ -466,7 +466,7 @@ voodoo auth secret-key
 
 ## Project Status & Roadmap
 
-Voodoo is in active development (v1.16.0, Beta). The core runtime, UI system, AI agents, MCP, durable execution, and adaptive runtime are production-ready. PostgreSQL, S3/R2, and Redis adapters are shipped behind optional extras; the AI runtime (model-provider protocol, memory, durable agents, and durable human-in-the-loop) is the current focus.
+Voodoo is in active development (v2.0.0, Beta). The core runtime, UI system, AI agents, MCP, durable execution, adaptive runtime, model-provider protocol, layered memory, and durable agent registry are production-ready. PostgreSQL, S3/R2, and Redis adapters are shipped behind optional extras; durable human-in-the-loop is the current focus.
 
 ```mermaid
 timeline
@@ -477,26 +477,20 @@ timeline
         Unified Runtime : ExecutionEngine : Planner : Adaptive supervisor
         Durable Local Runtime : SQLite queue : Executions : Scheduler : Objects : Events
         Production Providers : PostgreSQL : S3/R2 : Redis
-    section In Progress (v1.16–v1.19)
+    section Shipped (v1.16–v2.0)
         ModelProvider protocol : Model descriptors : Routing aliases
         Memory capability : Layered memory : SQLite + FTS5
-        Durable Agents & HITL : Agent registry : Resumable approvals
-    section Planned (v2.0+)
-        Capability Security & Secrets : v2.0
-        Observability & Protocol : v2.1–v2.2
-        Local Runtime DX : v2.3
-```
-
-| Milestone | Version | Status |
-|-----------|---------|--------|
-| Core framework — runtime, UI, routing, reactive state | v1.0–v1.1 | ✅ Shipped |
-| AI & unified runtime — agents, tools, MCP, HITL, ExecutionEngine, planner, adaptive runtime | v1.2 | ✅ Shipped |
-| Durable local runtime (zero-infra) — SQLite storage, queue, executions, scheduler, objects, events | v1.3–v1.9 | ✅ Shipped |
-| Adapter contracts & runtime configuration | v1.10–v1.11 | ✅ Shipped |
-| Production providers (optional) — PostgreSQL, S3/R2, Redis | v1.12–v1.15 | ✅ Shipped |
-| AI runtime — model-provider protocol, memory, durable agents, durable HITL | v1.16–v1.19 | 🚧 In Progress |
-| Capability security & secrets | v2.0 | 📋 Planned |
-| Protocol stability & DX — observability, schemas, local runtime | v2.1–v2.3 | 📋 Planned |
+        Durable Agents : Agent registry : v2.0
+    section In Progress (v2.1)
+        Durable HITL : Resumable approvals
+    section Planned (v2.2+)
+        Capability Security & Secrets : v2.2
+        Observability & Protocol : v2.3–v2.4
+        Local Runtime DX : v2.5
+| AI runtime — model-provider protocol, memory, durable agent registry | v1.16–v2.0 | ✅ Shipped |
+| Durable human-in-the-loop — resumable approvals | v2.1 | 🚧 In Progress |
+| Capability security & secrets | v2.2 | 📋 Planned |
+| Protocol stability & DX — observability, schemas, local runtime | v2.3–v2.5 | 📋 Planned |
 
 See the [master roadmap](ROADMAP.md) and [sprint plan](SPRINT_PLAN.md) for details.
 

{voodoo_framework-2.0.0 → voodoo_framework-2.2.0}/README.md

@@ -403,7 +403,7 @@ voodoo auth secret-key
 
 ## Project Status & Roadmap
 
-Voodoo is in active development (v1.16.0, Beta). The core runtime, UI system, AI agents, MCP, durable execution, and adaptive runtime are production-ready. PostgreSQL, S3/R2, and Redis adapters are shipped behind optional extras; the AI runtime (model-provider protocol, memory, durable agents, and durable human-in-the-loop) is the current focus.
+Voodoo is in active development (v2.0.0, Beta). The core runtime, UI system, AI agents, MCP, durable execution, adaptive runtime, model-provider protocol, layered memory, and durable agent registry are production-ready. PostgreSQL, S3/R2, and Redis adapters are shipped behind optional extras; durable human-in-the-loop is the current focus.
 
 ```mermaid
 timeline
@@ -414,26 +414,20 @@ timeline
         Unified Runtime : ExecutionEngine : Planner : Adaptive supervisor
         Durable Local Runtime : SQLite queue : Executions : Scheduler : Objects : Events
         Production Providers : PostgreSQL : S3/R2 : Redis
-    section In Progress (v1.16–v1.19)
+    section Shipped (v1.16–v2.0)
         ModelProvider protocol : Model descriptors : Routing aliases
         Memory capability : Layered memory : SQLite + FTS5
-        Durable Agents & HITL : Agent registry : Resumable approvals
-    section Planned (v2.0+)
-        Capability Security & Secrets : v2.0
-        Observability & Protocol : v2.1–v2.2
-        Local Runtime DX : v2.3
-```
-
-| Milestone | Version | Status |
-|-----------|---------|--------|
-| Core framework — runtime, UI, routing, reactive state | v1.0–v1.1 | ✅ Shipped |
-| AI & unified runtime — agents, tools, MCP, HITL, ExecutionEngine, planner, adaptive runtime | v1.2 | ✅ Shipped |
-| Durable local runtime (zero-infra) — SQLite storage, queue, executions, scheduler, objects, events | v1.3–v1.9 | ✅ Shipped |
-| Adapter contracts & runtime configuration | v1.10–v1.11 | ✅ Shipped |
-| Production providers (optional) — PostgreSQL, S3/R2, Redis | v1.12–v1.15 | ✅ Shipped |
-| AI runtime — model-provider protocol, memory, durable agents, durable HITL | v1.16–v1.19 | 🚧 In Progress |
-| Capability security & secrets | v2.0 | 📋 Planned |
-| Protocol stability & DX — observability, schemas, local runtime | v2.1–v2.3 | 📋 Planned |
+        Durable Agents : Agent registry : v2.0
+    section In Progress (v2.1)
+        Durable HITL : Resumable approvals
+    section Planned (v2.2+)
+        Capability Security & Secrets : v2.2
+        Observability & Protocol : v2.3–v2.4
+        Local Runtime DX : v2.5
+| AI runtime — model-provider protocol, memory, durable agent registry | v1.16–v2.0 | ✅ Shipped |
+| Durable human-in-the-loop — resumable approvals | v2.1 | 🚧 In Progress |
+| Capability security & secrets | v2.2 | 📋 Planned |
+| Protocol stability & DX — observability, schemas, local runtime | v2.3–v2.5 | 📋 Planned |
 
 See the [master roadmap](ROADMAP.md) and [sprint plan](SPRINT_PLAN.md) for details.
 

{voodoo_framework-2.0.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.0.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.0.0 → voodoo_framework-2.2.0}/src/voodoo/cli/__init__.py

@@ -3,6 +3,7 @@ import typer
 from voodoo.cli import (
     agents,
     ai,
+    approvals,
     dev,
     doctor,
     executions,
@@ -38,6 +39,7 @@ app.add_typer(schedules.schedules_app, name="schedules")
 app.add_typer(executions.executions_app, name="executions")
 app.add_typer(objects.objects_app, name="objects")
 app.add_typer(agents.agents_app, name="agents")
+app.add_typer(approvals.approvals_app, name="approvals")
 app.add_typer(theme.theme_app, name="theme")
 # Top-level aliases per the Sprint 3 CLI surface: `voodoo execution <id>`
 # (timeline from the journal) and `voodoo events` (recent journal events).

voodoo_framework-2.2.0/src/voodoo/cli/approvals.py

@@ -0,0 +1,283 @@
+"""voodoo approvals — decide pending human approvals from any machine.
+
+Sprint 18: human approval is an execution state that survives process
+death. This CLI reads and decides approvals directly from the durable
+execution store (SQLite by default), so a decision can be made on any
+machine — the waiting execution resumes on whichever worker picks it up.
+
+    voodoo approvals list [--pending] [--json]
+    voodoo approvals show <execution-id> [--json]
+    voodoo approvals approve <execution-id> [--by NAME] [--note TEXT]
+    voodoo approvals deny <execution-id> [--by NAME] [--reason TEXT]
+
+With ``--app`` (e.g. ``main:app``) the application module is imported
+first so registered participants (agents, workflows) re-register and the
+approved execution actually re-runs.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+from pathlib import Path
+
+import typer
+
+from voodoo.cli import terminal
+
+approvals_app = typer.Typer(
+    name="approvals",
+    help="List, approve, and deny human approvals.",
+    no_args_is_help=True,
+    rich_markup_mode="rich",
+)
+
+
+def _resolve_store(store_path: str | None):
+    """Return the configured execution store (SQLite by default)."""
+    from voodoo.config import config
+    from voodoo.runtime.persistence import JSONFileExecutionStore
+    from voodoo.storage.execution import SQLiteExecutionStore
+
+    if store_path is None:
+        store_path = os.environ.get("VOODOO_EXECUTION_STORE", config.db_path).replace(
+            ":memory:", ".voodoo/state/data.db"
+        )
+
+    if Path(store_path).suffix == ".jsonl":
+        return JSONFileExecutionStore(store_path), store_path
+    return SQLiteExecutionStore(store_path), store_path
+
+
+def _load_app(app_str: str | None) -> None:
+    """Import the application module so participants re-register."""
+    if app_str is None:
+        return
+    import importlib
+    import sys
+
+    module_name, _, attr = app_str.partition(":")
+    attr = attr or "app"
+    sys.path.insert(0, os.getcwd())
+    mod = importlib.import_module(module_name)
+    getattr(mod, attr, None)
+
+
+def _list_approvals(store, pending_only: bool) -> list[dict]:
+    """Read approvals from a store, tolerating stores without the seam."""
+    if not hasattr(store, "load_approvals"):
+        return []
+    return store.load_approvals(pending_only=pending_only)
+
+
+@approvals_app.command("list")
+def list_approvals(
+    pending_only: bool = typer.Option(
+        False, "--pending", help="Only show pending approvals"
+    ),
+    store_path: str = typer.Option(
+        None, "--store", help="Path to the execution store (SQLite by default)"
+    ),
+    app_str: str = typer.Option(
+        None, "--app", help="App instance (e.g. main:app) to import first"
+    ),
+    json_mode: bool = typer.Option(
+        False, "--json", help="Machine-readable JSON output"
+    ),
+):
+    """List approvals — pending and decided."""
+    store, resolved = _resolve_store(store_path)
+    _load_app(app_str)
+    approvals = _list_approvals(store, pending_only)
+
+    if json_mode or terminal.is_json_mode():
+        terminal.json_output({"store": resolved, "approvals": approvals})
+        return
+
+    terminal.wordmark()
+    terminal.blank()
+    if not approvals:
+        terminal.muted(
+            f"no {'pending ' if pending_only else ''}approvals in {resolved}"
+        )
+        return
+    for a in approvals:
+        terminal.info(
+            f"  {str(a.get('id', ''))[:8]}  {(a.get('question') or '-')[:60]}"
+        )
+        terminal.muted(
+            f"    execution: {str(a.get('execution_id', ''))[:8]}"
+            f"  status: {a.get('status', '-')}"
+        )
+        terminal.muted(
+            f"    requested_by: {a.get('requested_by') or '-'}"
+            f"  decided_by: {a.get('decided_by') or '-'}"
+        )
+        terminal.blank()
+
+
+@approvals_app.command("show")
+def show_approval(
+    execution_id: str = typer.Argument(..., help="Execution id of the approval"),
+    store_path: str = typer.Option(
+        None, "--store", help="Path to the execution store (SQLite by default)"
+    ),
+    json_mode: bool = typer.Option(
+        False, "--json", help="Machine-readable JSON output"
+    ),
+):
+    """Show one approval in detail."""
+    store, resolved = _resolve_store(store_path)
+    approval = (
+        store.load_approval(execution_id) if hasattr(store, "load_approval") else None
+    )
+    if approval is None:
+        terminal.error(
+            f"approval for execution '{execution_id}' not found in {resolved}"
+        )
+        raise typer.Exit(1)
+
+    if json_mode or terminal.is_json_mode():
+        terminal.json_output(approval)
+        return
+
+    terminal.wordmark()
+    terminal.blank()
+    terminal.status_block(
+        [
+            ("id", str(approval.get("id", ""))),
+            ("execution", str(approval.get("execution_id", ""))),
+            ("trace", str(approval.get("trace_id", "") or "-")),
+            ("status", approval.get("status", "-")),
+            ("requested_by", approval.get("requested_by") or "-"),
+            ("decided_by", approval.get("decided_by") or "-"),
+            ("decided_at", approval.get("decided_at") or "-"),
+            ("participant", approval.get("participant") or "-"),
+        ]
+    )
+    question = approval.get("question")
+    if question:
+        terminal.blank()
+        terminal.label_value("question", question)
+    reason = approval.get("reason")
+    if reason:
+        terminal.label_value("reason", reason)
+    terminal.blank()
+
+
+def _decide(
+    execution_id: str,
+    *,
+    decision: str,
+    by: str,
+    message: str | None,
+    store_path: str | None,
+    app_str: str | None,
+    json_mode: bool,
+) -> None:
+    """Shared approve/deny path: recover waiting executions, then decide."""
+    from voodoo.runtime.engine import engine as runtime_engine
+
+    store, resolved = _resolve_store(store_path)
+    runtime_engine.use_store(store)
+    # Restore waiting executions + rehydrate persisted approvals so the
+    # decision applies to the durable record — not just this process.
+    runtime_engine.recover()
+    _load_app(app_str)
+
+    if runtime_engine.approvals.get(execution_id) is None:
+        if json_mode or terminal.is_json_mode():
+            terminal.json_output(
+                {
+                    "error": "approval not found",
+                    "execution_id": execution_id,
+                    "store": resolved,
+                }
+            )
+        else:
+            terminal.error(f"approval for execution '{execution_id}' not found")
+        raise typer.Exit(1)
+
+    decide_fn = runtime_engine.approve if decision == "approve" else runtime_engine.deny
+    kwargs = {}
+    if decision == "approve":
+        kwargs["note"] = message
+    else:
+        kwargs["reason"] = message or "denied"
+    executed = asyncio.run(decide_fn(execution_id, by=by, **kwargs))
+
+    if json_mode or terminal.is_json_mode():
+        terminal.json_output(
+            {
+                "store": resolved,
+                "decision": decision,
+                "execution_id": execution_id,
+                "by": by,
+                "resumed": executed.describe() if executed is not None else None,
+            }
+        )
+        return
+
+    terminal.wordmark()
+    terminal.blank()
+    icon = "✓" if decision == "approve" else "✗"
+    terminal.info(f"  {icon} {decision}d execution {execution_id[:8]} by {by}")
+    if executed is not None:
+        terminal.muted(f"    execution → {executed.status.value}")
+    else:
+        terminal.muted("    execution not found in engine (record updated only)")
+    terminal.blank()
+
+
+@approvals_app.command("approve")
+def approve_cmd(
+    execution_id: str = typer.Argument(..., help="Execution id to approve"),
+    by: str = typer.Option("human", "--by", help="Who is approving"),
+    note: str = typer.Option(None, "--note", help="Optional note"),
+    store_path: str = typer.Option(
+        None, "--store", help="Path to the execution store (SQLite by default)"
+    ),
+    app_str: str = typer.Option(
+        None, "--app", help="App instance (e.g. main:app) to import first"
+    ),
+    json_mode: bool = typer.Option(
+        False, "--json", help="Machine-readable JSON output"
+    ),
+):
+    """Approve a waiting execution — it resumes on a worker."""
+    _decide(
+        execution_id,
+        decision="approve",
+        by=by,
+        message=note,
+        store_path=store_path,
+        app_str=app_str,
+        json_mode=json_mode,
+    )
+
+
+@approvals_app.command("deny")
+def deny_cmd(
+    execution_id: str = typer.Argument(..., help="Execution id to deny"),
+    by: str = typer.Option("human", "--by", help="Who is denying"),
+    reason: str = typer.Option(None, "--reason", help="Denial reason"),
+    store_path: str = typer.Option(
+        None, "--store", help="Path to the execution store (SQLite by default)"
+    ),
+    app_str: str = typer.Option(
+        None, "--app", help="App instance (e.g. main:app) to import first"
+    ),
+    json_mode: bool = typer.Option(
+        False, "--json", help="Machine-readable JSON output"
+    ),
+):
+    """Deny a waiting execution — it fails with the denial reason."""
+    _decide(
+        execution_id,
+        decision="deny",
+        by=by,
+        message=reason,
+        store_path=store_path,
+        app_str=app_str,
+        json_mode=json_mode,
+    )

{voodoo_framework-2.0.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.0.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),
         }