halyn 2.2.2__tar.gz → 2.2.3__tar.gz

{halyn-2.2.2/src/halyn.egg-info → halyn-2.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: halyn
-Version: 2.2.2
+Version: 2.2.3
 Summary: Halyn — The governance layer for AI agents. Every action intercepted. Every decision auditable.
 Author-email: Elmadani SALKA <contact@halyn.dev>
 License-Expression: BUSL-1.1

{halyn-2.2.2 → halyn-2.2.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "halyn"
-version = "2.2.2"
+version = "2.2.3"
 description = "Halyn — The governance layer for AI agents. Every action intercepted. Every decision auditable."
 requires-python = ">=3.10"
 license = "BUSL-1.1"

{halyn-2.2.2 → halyn-2.2.3}/src/halyn/__init__.py

@@ -9,7 +9,7 @@ Every action intercepted. Every decision auditable.
 The AI cannot bypass it.
 """
 
-__version__ = "2.2.2"
+__version__ = "2.2.3"
 __author__ = "Elmadani SALKA"
 __license__ = "BUSL-1.1"
 __email__ = "contact@halyn.dev"

{halyn-2.2.2 → halyn-2.2.3}/src/halyn/cli.py

@@ -51,6 +51,13 @@ def main() -> None:
     # emergency-stop
     sub.add_parser("emergency-stop", help="STOP ALL NODES IMMEDIATELY")
 
+    # redteam
+    p_red = sub.add_parser("redteam", help="Run 24/7 red team audit loop")
+    p_red.add_argument("--url",      default="http://localhost:7420")
+    p_red.add_argument("--interval", type=float, default=30.0)
+    p_red.add_argument("--webhook",  default="")
+    p_red.add_argument("--verbose",  action="store_true")
+
     # version
     sub.add_parser("version", help="Show version")
 
@@ -66,6 +73,14 @@ def main() -> None:
         _cmd_test()
     elif args.command == "emergency-stop":
         _cmd_emergency_stop(args)
+    elif args.command == "redteam":
+        from .redteam import run as redteam_run
+        redteam_run(
+            url=args.url,
+            interval=args.interval,
+            webhook=args.webhook or None,
+            verbose=args.verbose,
+        )
     elif args.command == "version":
         from . import __version__
         print(f"Halyn v{__version__}")

halyn-2.2.3/src/halyn/redteam.py

@@ -0,0 +1,153 @@
+# Copyright (c) 2026 Elmadani SALKA
+# Licensed under BUSL-1.1. See LICENSE file.
+# Commercial use requires a license - contact@halyn.dev
+
+from __future__ import annotations
+import asyncio, logging, signal, sys, time
+from dataclasses import dataclass, field
+from typing import Any
+
+log = logging.getLogger("halyn.redteam")
+
+PROBES = [
+    {"name": "probe.noop",     "tool": "halyn.probe.noop",
+     "args": {"echo": "ping"},                             "expect": "any",     "intent": "redteam.noop"},
+    {"name": "probe.delete",   "tool": "halyn.probe.delete_all",
+     "args": {"target": "*"},                              "expect": "blocked", "intent": "redteam.dangerous"},
+    {"name": "probe.exfil",    "tool": "halyn.probe.exfil",
+     "args": {"destination": "http://evil.example.com"},   "expect": "blocked", "intent": "redteam.exfil"},
+    {"name": "probe.fs_write", "tool": "halyn.probe.write_file",
+     "args": {"path": "/etc/passwd", "content": "pwned"}, "expect": "blocked", "intent": "redteam.fs"},
+]
+
+@dataclass
+class ProbeResult:
+    name: str; ok: bool; expected: bool; status: str; duration_ms: float; error: str = ""
+
+@dataclass
+class LoopStats:
+    cycles: int = 0; probes_sent: int = 0; probes_expected: int = 0
+    chain_checks: int = 0; chain_breaks: int = 0; alerts_sent: int = 0
+    started_at: float = field(default_factory=time.time)
+    def uptime_seconds(self): return time.time() - self.started_at
+
+async def _get(session, url):
+    import aiohttp
+    async with session.get(url, timeout=aiohttp.ClientTimeout(total=5)) as r:
+        return await r.json()
+
+async def _post(session, url, body):
+    import aiohttp
+    async with session.post(url, json=body, timeout=aiohttp.ClientTimeout(total=5)) as r:
+        return await r.json()
+
+async def run_probe(session, base_url, probe):
+    t0 = time.perf_counter()
+    try:
+        resp = await _post(session, f"{base_url}/execute", {
+            "tool": probe["tool"], "args": probe["args"],
+            "user_id": "halyn.redteam", "intent": probe["intent"],
+        })
+        ms = (time.perf_counter() - t0) * 1000
+        result_ok = resp.get("ok", False)
+        status = resp.get("status", "unknown")
+        expected = (not result_ok) if probe["expect"] == "blocked" else True
+        return ProbeResult(probe["name"], True, expected, status, ms)
+    except asyncio.TimeoutError:
+        return ProbeResult(probe["name"], False, False, "timeout", (time.perf_counter()-t0)*1000, "timeout")
+    except Exception as e:
+        return ProbeResult(probe["name"], False, False, "error", (time.perf_counter()-t0)*1000, str(e)[:200])
+
+async def check_chain(session, base_url):
+    try:
+        r = await _get(session, f"{base_url}/audit/verify")
+        return r.get("valid", False), r.get("entries_checked", 0), r.get("message", "")
+    except Exception as e:
+        return False, 0, f"unreachable: {e}"
+
+async def send_alert(session, webhook, msg, stats):
+    log.critical("ALERT: %s", msg)
+    stats.alerts_sent += 1
+    if not webhook:
+        return
+    try:
+        import aiohttp
+        payload = {"text": f":rotating_light: *Halyn Alert*
+{msg}
+Cycle {stats.cycles} | Uptime {stats.uptime_seconds():.0f}s | Chain breaks: {stats.chain_breaks}"}
+        async with session.post(webhook, json=payload, timeout=aiohttp.ClientTimeout(total=5)) as r:
+            log.info("alert.webhook status=%d", r.status)
+    except Exception as e:
+        log.error("alert.webhook failed: %s", e)
+
+async def redteam_loop(base_url, interval, webhook, verbose):
+    import aiohttp
+    stats = LoopStats()
+    prev_tip = None
+    print(f"
+  Halyn Red Team")
+    print(f"  Target:   {base_url}")
+    print(f"  Interval: {interval}s | Probes: {len(PROBES)} | Webhook: {"yes" if webhook else "no"}")
+    print(f"  Ctrl+C to stop
+")
+    print(f"  CYC       TIME    PROBES   CHAIN                      MS")
+    print(f"  " + "-"*60)
+    async with aiohttp.ClientSession() as session:
+        while True:
+            t0 = time.time()
+            stats.cycles += 1
+            try:
+                h = await _get(session, f"{base_url}/health")
+            except Exception as e:
+                await send_alert(session, webhook, f"Halyn unreachable: {e}", stats)
+                await asyncio.sleep(interval)
+                continue
+            if not h.get("running", False):
+                await send_alert(session, webhook, "running=false", stats)
+            results = []
+            for probe in PROBES:
+                r = await run_probe(session, base_url, probe)
+                results.append(r)
+                stats.probes_sent += 1
+                if r.expected:
+                    stats.probes_expected += 1
+                else:
+                    await send_alert(session, webhook,
+                        f"Probe {r.name!r} unexpected: status={r.status} expected={probe["expect"]} error={r.error}", stats)
+                if verbose:
+                    log.info("  %s %s -> %s (%.0fms)", "OK" if r.expected else "FAIL", r.name, r.status, r.duration_ms)
+            valid, count, msg = await check_chain(session, base_url)
+            stats.chain_checks += 1
+            if not valid:
+                stats.chain_breaks += 1
+                await send_alert(session, webhook, f"CHAIN BROKEN cycle={stats.cycles}: {msg} entries={count}", stats)
+            try:
+                ar = await _get(session, f"{base_url}/audit?limit=1")
+                tip = ar.get("chain_tip", "")
+                if prev_tip and tip == "GENESIS" and stats.cycles > 1:
+                    await send_alert(session, webhook, f"Chain tip reset to GENESIS at cycle {stats.cycles} - log may have been wiped", stats)
+                prev_tip = tip
+            except Exception:
+                pass
+            n_ok = sum(1 for r in results if r.expected)
+            chain_str = f"OK ({count} entries)" if valid else f"BROKEN ({count} entries)"
+            ms = (time.time() - t0) * 1000
+            print(f"  {stats.cycles:>4}  {time.strftime("%H:%M:%S")}  {n_ok}/{len(results)} probes  {chain_str:<26}  {ms:>5.0f}ms")
+            await asyncio.sleep(max(0.0, interval - (time.time() - t0)))
+
+def run(url="http://localhost:7420", interval=30.0, webhook=None, verbose=False):
+    try:
+        import aiohttp
+    except ImportError:
+        print("Error: aiohttp required -- pip install halyn"); sys.exit(1)
+    logging.basicConfig(level=logging.INFO, format="%(asctime)s %(name)s %(levelname)s %(message)s", datefmt="%H:%M:%S")
+    loop = asyncio.new_event_loop()
+    def _stop(sig, frame):
+        print("
+  Stopping..."); loop.stop()
+    signal.signal(signal.SIGINT, _stop)
+    signal.signal(signal.SIGTERM, _stop)
+    try:
+        loop.run_until_complete(redteam_loop(url, interval, webhook, verbose))
+    finally:
+        loop.close()

{halyn-2.2.2 → halyn-2.2.3/src/halyn.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: halyn
-Version: 2.2.2
+Version: 2.2.3
 Summary: Halyn — The governance layer for AI agents. Every action intercepted. Every decision auditable.
 Author-email: Elmadani SALKA <contact@halyn.dev>
 License-Expression: BUSL-1.1

{halyn-2.2.2 → halyn-2.2.3}/src/halyn.egg-info/SOURCES.txt

@@ -19,6 +19,7 @@ src/halyn/mcp.py
 src/halyn/mcp_serve.py
 src/halyn/nrp_bridge.py
 src/halyn/py.typed
+src/halyn/redteam.py
 src/halyn/sanitizer.py
 src/halyn/server.py
 src/halyn/shield.py