failproofai 1.0.5 → 1.0.6-beta.0

package/.next/standalone/hermes-plugin/client.py

@@ -0,0 +1,134 @@
+"""Versioned Unix-socket client for failproofaid policy evaluation."""
+
+from __future__ import annotations
+
+import json
+import os
+import socket
+import struct
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Mapping, Sequence
+
+PROTOCOL_VERSION = 1
+MAX_FRAME_BYTES = 16 * 1024 * 1024
+MAX_REQUEST_BYTES = 1024 * 1024
+
+
+class EvaluationError(RuntimeError):
+    """The daemon could not return a trustworthy policy verdict."""
+
+
+@dataclass(frozen=True)
+class PolicyVerdict:
+    decision: str
+    policy_names: tuple[str, ...]
+    reason: str | None
+    matched_policies: tuple[str, ...]
+    duration_ms: int
+    tool_name: str | None
+
+
+def daemon_socket_path() -> Path:
+    override = os.environ.get("FAILPROOFAI_DAEMON_SOCKET", "").strip()
+    if override:
+        return Path(override).expanduser()
+    root = os.environ.get("FAILPROOFAI_HOME", "").strip()
+    home = Path(root).expanduser() if root else Path.home() / ".failproofai"
+    return home / "run" / "failproofaid.sock"
+
+
+def _read_exact(sock: socket.socket, length: int) -> bytes:
+    chunks: list[bytes] = []
+    remaining = length
+    while remaining:
+        chunk = sock.recv(remaining)
+        if not chunk:
+            raise EvaluationError("failproofaid closed the connection before returning a verdict")
+        chunks.append(chunk)
+        remaining -= len(chunk)
+    return b"".join(chunks)
+
+
+def _string_list(value: object, field: str) -> tuple[str, ...]:
+    if not isinstance(value, Sequence) or isinstance(value, (str, bytes, bytearray)):
+        raise EvaluationError(f"failproofaid returned an invalid {field}")
+    if not all(isinstance(item, str) for item in value):
+        raise EvaluationError(f"failproofaid returned an invalid {field}")
+    return tuple(value)
+
+
+def evaluate_policy(
+    *,
+    event: str,
+    payload: Mapping[str, Any],
+    cwd: str | None,
+    connect_timeout_ms: int = 250,
+    evaluation_timeout_ms: int = 12_000,
+) -> PolicyVerdict:
+    request = {
+        "type": "policyEvaluation",
+        "protocolVersion": PROTOCOL_VERSION,
+        "integration": "hermes",
+        "event": event,
+        "payload": dict(payload),
+        "cwd": cwd,
+    }
+    try:
+        body = json.dumps(
+            request,
+            ensure_ascii=False,
+            separators=(",", ":"),
+            default=lambda value: repr(value),
+        ).encode("utf-8")
+    except (TypeError, ValueError) as exc:
+        raise EvaluationError(f"could not encode policy request: {exc}") from exc
+    if len(body) > MAX_REQUEST_BYTES:
+        raise EvaluationError("policy request exceeds the 1 MiB limit")
+
+    try:
+        with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as sock:
+            sock.settimeout(max(connect_timeout_ms, 1) / 1000)
+            sock.connect(str(daemon_socket_path()))
+            sock.settimeout(max(evaluation_timeout_ms, 1) / 1000)
+            sock.sendall(struct.pack(">I", len(body)) + body)
+            declared_length = struct.unpack(">I", _read_exact(sock, 4))[0]
+            if declared_length > MAX_FRAME_BYTES:
+                raise EvaluationError("failproofaid response exceeds the 16 MiB limit")
+            response = json.loads(_read_exact(sock, declared_length).decode("utf-8"))
+    except EvaluationError:
+        raise
+    except (OSError, UnicodeError, ValueError, struct.error) as exc:
+        raise EvaluationError(f"failproofaid evaluation failed: {exc}") from exc
+
+    if not isinstance(response, dict):
+        raise EvaluationError("failproofaid returned a non-object response")
+    if response.get("protocolVersion") != PROTOCOL_VERSION:
+        raise EvaluationError("failproofaid protocol version mismatch")
+    if response.get("type") == "error":
+        message = response.get("message")
+        raise EvaluationError(str(message or "failproofaid could not evaluate the policy"))
+    if response.get("type") != "policyResult":
+        raise EvaluationError("failproofaid does not support native policy evaluation")
+
+    decision = response.get("decision")
+    if decision not in {"allow", "deny", "instruct"}:
+        raise EvaluationError("failproofaid returned an invalid policy decision")
+    reason = response.get("reason")
+    if reason is not None and not isinstance(reason, str):
+        raise EvaluationError("failproofaid returned an invalid policy reason")
+    duration_ms = response.get("durationMs", 0)
+    if not isinstance(duration_ms, int) or duration_ms < 0:
+        raise EvaluationError("failproofaid returned an invalid evaluation duration")
+    tool_name = response.get("toolName")
+    if tool_name is not None and not isinstance(tool_name, str):
+        raise EvaluationError("failproofaid returned an invalid tool name")
+
+    return PolicyVerdict(
+        decision=decision,
+        policy_names=_string_list(response.get("policyNames", []), "policyNames"),
+        reason=reason,
+        matched_policies=_string_list(response.get("matchedPolicies", []), "matchedPolicies"),
+        duration_ms=duration_ms,
+        tool_name=tool_name,
+    )

package/.next/standalone/hermes-plugin/ledger.py

@@ -0,0 +1,187 @@
+"""Persistent, bounded delivery state for FailproofAI instruct decisions."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import sqlite3
+import threading
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Sequence
+
+
+class LedgerError(RuntimeError):
+    """Instruction state could not be read or updated safely."""
+
+
+@dataclass(frozen=True)
+class InstructionAction:
+    block: bool
+    status: str
+
+
+class InstructionLedger:
+    def __init__(self, path: Path, *, ttl_seconds: int = 3600, max_rounds: int = 2) -> None:
+        self.path = path
+        self.ttl_seconds = max(60, int(ttl_seconds))
+        self.max_rounds = max(0, int(max_rounds))
+        self._init_lock = threading.Lock()
+        self._initialized = False
+
+    def _connect(self) -> sqlite3.Connection:
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        connection = sqlite3.connect(self.path, timeout=0.25, isolation_level=None)
+        connection.execute("PRAGMA busy_timeout = 250")
+        connection.execute("PRAGMA journal_mode = WAL")
+        connection.execute("PRAGMA synchronous = NORMAL")
+        return connection
+
+    def _ensure_schema(self) -> None:
+        if self._initialized:
+            return
+        with self._init_lock:
+            if self._initialized:
+                return
+            try:
+                with self._connect() as connection:
+                    connection.execute(
+                        """
+                        CREATE TABLE IF NOT EXISTS instruction_deliveries (
+                          delivery_key TEXT PRIMARY KEY,
+                          profile TEXT NOT NULL,
+                          session_id TEXT NOT NULL,
+                          task_id TEXT NOT NULL,
+                          turn_id TEXT NOT NULL,
+                          policy_fingerprint TEXT NOT NULL,
+                          scope_key TEXT NOT NULL,
+                          blocked_api_request_id TEXT NOT NULL,
+                          acknowledged_api_request_id TEXT,
+                          state TEXT NOT NULL,
+                          created_at_ms INTEGER NOT NULL,
+                          expires_at_ms INTEGER NOT NULL
+                        )
+                        """
+                    )
+                    connection.execute(
+                        """
+                        CREATE INDEX IF NOT EXISTS instruction_deliveries_turn
+                        ON instruction_deliveries(profile, session_id, task_id, turn_id, expires_at_ms)
+                        """
+                    )
+            except sqlite3.Error as exc:
+                raise LedgerError(f"could not initialize instruction state: {exc}") from exc
+            self._initialized = True
+
+    @staticmethod
+    def _digest(parts: Sequence[str]) -> str:
+        encoded = json.dumps(list(parts), ensure_ascii=False, separators=(",", ":")).encode("utf-8")
+        return hashlib.sha256(encoded).hexdigest()
+
+    def decide(
+        self,
+        *,
+        profile: str,
+        session_id: str,
+        task_id: str,
+        turn_id: str,
+        api_request_id: str,
+        policy_names: Sequence[str],
+        reason: str,
+        scope_key: str,
+        now_ms: int | None = None,
+    ) -> InstructionAction:
+        if not session_id or not turn_id or not api_request_id:
+            return InstructionAction(False, "missing-correlation-id")
+
+        self._ensure_schema()
+        now = int(time.time() * 1000) if now_ms is None else int(now_ms)
+        expires_at = now + self.ttl_seconds * 1000
+        task = task_id or "root"
+        policy_fingerprint = self._digest([*sorted(policy_names), reason])
+        delivery_key = self._digest(
+            [profile, session_id, task, turn_id, policy_fingerprint, scope_key]
+        )
+
+        try:
+            with self._connect() as connection:
+                connection.execute("BEGIN IMMEDIATE")
+                connection.execute(
+                    "DELETE FROM instruction_deliveries WHERE expires_at_ms <= ?", (now,)
+                )
+                row = connection.execute(
+                    """
+                    SELECT blocked_api_request_id, state
+                    FROM instruction_deliveries
+                    WHERE delivery_key = ?
+                    """,
+                    (delivery_key,),
+                ).fetchone()
+                if row is not None:
+                    blocked_request, state = row
+                    if state == "issued" and blocked_request == api_request_id:
+                        connection.commit()
+                        return InstructionAction(True, "same-api-request")
+                    if state == "issued":
+                        connection.execute(
+                            """
+                            UPDATE instruction_deliveries
+                            SET state = 'acknowledged', acknowledged_api_request_id = ?
+                            WHERE delivery_key = ?
+                            """,
+                            (api_request_id, delivery_key),
+                        )
+                    connection.commit()
+                    return InstructionAction(False, "acknowledged")
+
+                rounds = connection.execute(
+                    """
+                    SELECT COUNT(*)
+                    FROM instruction_deliveries
+                    WHERE profile = ? AND session_id = ? AND task_id = ? AND turn_id = ?
+                      AND expires_at_ms > ?
+                    """,
+                    (profile, session_id, task, turn_id, now),
+                ).fetchone()[0]
+                if rounds >= self.max_rounds:
+                    connection.commit()
+                    return InstructionAction(False, "turn-cap")
+
+                connection.execute(
+                    """
+                    INSERT INTO instruction_deliveries (
+                      delivery_key, profile, session_id, task_id, turn_id,
+                      policy_fingerprint, scope_key, blocked_api_request_id,
+                      acknowledged_api_request_id, state, created_at_ms, expires_at_ms
+                    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, NULL, 'issued', ?, ?)
+                    """,
+                    (
+                        delivery_key,
+                        profile,
+                        session_id,
+                        task,
+                        turn_id,
+                        policy_fingerprint,
+                        scope_key,
+                        api_request_id,
+                        now,
+                        expires_at,
+                    ),
+                )
+                connection.commit()
+                return InstructionAction(True, "issued")
+        except (sqlite3.Error, OSError) as exc:
+            raise LedgerError(f"could not update instruction state: {exc}") from exc
+
+    def clear_session(self, session_id: str) -> None:
+        if not session_id:
+            return
+        self._ensure_schema()
+        try:
+            with self._connect() as connection:
+                connection.execute(
+                    "DELETE FROM instruction_deliveries WHERE session_id = ?", (session_id,)
+                )
+        except (sqlite3.Error, OSError) as exc:
+            raise LedgerError(f"could not clear instruction state: {exc}") from exc

package/.next/standalone/hermes-plugin/plugin.yaml

@@ -0,0 +1,37 @@
+name: failproofai
+version: 1.0.6-beta.0
+description: Real-time FailproofAI policy enforcement for Hermes
+manifest_version: 2
+api_version: 1
+homepage: https://github.com/FailproofAI/failproofai
+tags: [security, policy, observability]
+provides_hooks:
+  - pre_tool_call
+  - post_tool_call
+  - pre_llm_call
+  - on_session_start
+  - on_session_end
+  - on_session_reset
+  - on_session_finalize
+  - subagent_stop
+config_schema:
+  failure_mode:
+    type: str
+    default: deny
+    description: Block or allow when the local FailproofAI evaluator is unavailable.
+  connect_timeout_ms:
+    type: int
+    default: 250
+    description: Maximum time to connect to the local FailproofAI daemon.
+  evaluation_timeout_ms:
+    type: int
+    default: 12000
+    description: Maximum total time allowed for one policy evaluation.
+  instruction_ttl_seconds:
+    type: int
+    default: 3600
+    description: Maximum lifetime of an instruction-delivery record.
+  max_instruction_rounds:
+    type: int
+    default: 2
+    description: Maximum distinct instruction interruptions in one Hermes turn.

package/.next/standalone/node_modules/@next/env/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@next/env",
-  "version": "16.3.4",
+  "version": "16.3.5",
   "keywords": [
     "react",
     "next",

package/.next/standalone/node_modules/next/dist/build/swc/index.js

@@ -139,7 +139,7 @@ var HmrTarget = /*#__PURE__*/ function(HmrTarget) {
     HmrTarget["Server"] = "server";
     return HmrTarget;
 }({});
-const nextVersion = "16.3.4";
+const nextVersion = "16.3.5";
 const ArchName = (0, _os.arch)();
 const PlatformName = (0, _os.platform)();
 function infoLog(...args) {