countersign-agent 0.10.0__py3-none-any.whl

countersign/__init__.py

@@ -0,0 +1,3 @@
+"""countersign — What You Approve eXecutes."""
+
+__version__ = "0.10.0"

countersign/alerts.py

@@ -0,0 +1,64 @@
+"""Named delivery for alerts — the line must reach something a human reads.
+
+`anchor watch` prints one line and exits with honest codes, but a line
+nobody reads is not an alert: `--notify-cmd` runs a command with the
+report as its last argument, `--notify-file` appends the report to a
+file. Drift notices (census and MCP) honor the same mechanism through
+the environment: `COUNTERSIGN_ALERT_HOOK` (command) and `COUNTERSIGN_ALERT_FILE`.
+
+Honest mechanics:
+- delivery runs with the privileges of the process that noticed the
+  problem — cron's for watch, the hook/proxy process for drift. Point it
+  only at things you trust to run there; countersign never escalates it.
+- a failed delivery is REPORTED (stderr for watch, stderr for drift) and
+  never changes the original exit code: BROKEN stays 2 even when the
+  alerter is dead — that is two problems, not zero.
+- no hook configured = nothing runs. The inbox and the terminal line
+  stay the record of truth.
+"""
+from __future__ import annotations
+import os
+import shlex
+import subprocess
+import time
+from pathlib import Path
+
+
+def deliver(reason: str, *, cmd: str | None = None,
+            file: str | None = None) -> list[str]:
+    """Run the alert hooks. Returns delivery errors (empty = delivered).
+
+    Explicit `cmd`/`file` win; unset ones fall back to COUNTERSIGN_ALERT_HOOK /
+    COUNTERSIGN_ALERT_FILE so drift notices use the same wiring. The reason is
+    appended as the hook's last argument / the file's line payload.
+    """
+    errs: list[str] = []
+    if cmd is None:
+        cmd = os.environ.get("COUNTERSIGN_ALERT_HOOK") or None
+    if file is None:
+        file = os.environ.get("COUNTERSIGN_ALERT_FILE") or None
+    if cmd:
+        try:
+            argv = shlex.split(cmd)
+            if not argv:
+                errs.append("alert hook is empty")
+            else:
+                r = subprocess.run(argv + [reason], capture_output=True,
+                                   text=True, timeout=15)
+                if r.returncode != 0:
+                    errs.append(f"alert hook exited {r.returncode}: "
+                                f"{(r.stderr or r.stdout).strip()[:200]}")
+        except FileNotFoundError:
+            errs.append(f"alert hook not found: {shlex.split(cmd)[0]}")
+        except (OSError, ValueError, subprocess.SubprocessError) as e:
+            errs.append(f"alert hook failed: {e}")
+    if file:
+        try:
+            p = Path(file).expanduser()
+            p.parent.mkdir(parents=True, exist_ok=True)
+            stamp = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
+            with open(p, "a", encoding="utf-8") as f:
+                f.write(f"{stamp} {reason}\n")
+        except OSError as e:
+            errs.append(f"alert file write failed: {e}")
+    return errs

countersign/ask.py

@@ -0,0 +1,148 @@
+"""HITL channel owned by MITL.
+
+The agent never sees this prompt. Backends, strongest first:
+  COUNTERSIGN_ASK=allow|deny   — tests / unattended explicit
+  socket                — countersign-askd if running
+  osascript / zenity    — native dialog showing the render
+  fallback              — DENY. There is no allow-when-nobody-is-there.
+
+Never prompt on the agent's tty: that is how LITL padding works.
+"""
+from __future__ import annotations
+import json
+import os
+import socket
+import subprocess
+import sys
+from shutil import which
+
+from .config import home
+
+ALLOW, DENY = "allow", "deny"
+
+
+def timeout() -> float:
+    try:
+        return float(os.environ.get("COUNTERSIGN_TIMEOUT", "60"))
+    except ValueError:
+        return 60.0
+
+
+def sock_path():
+    return home() / "ask.sock"
+
+
+def decide(text: str, digest: str, tags: list[str] | None = None
+           ) -> tuple[str, str]:
+    """Return (allow|deny, backend). Unreachable human → deny."""
+    forced = os.environ.get("COUNTERSIGN_ASK", "").strip().lower()
+    if forced in (ALLOW, DENY):
+        return forced, f"env:{forced}"
+    for name in _order():
+        fn = _BACKENDS.get(name)
+        if not fn:
+            continue
+        got = fn(text, digest, timeout(), tags or [])
+        if got in (ALLOW, DENY):
+            return got, name
+    return DENY, "unattended-deny"
+
+
+def _order() -> list[str]:
+    raw = os.environ.get("COUNTERSIGN_ASK_BACKEND", "").strip()
+    if raw:
+        return [x.strip() for x in raw.split(",") if x.strip()]
+    out = []
+    if sock_path().exists():
+        out.append("socket")
+    if sys.platform == "darwin" and which("osascript"):
+        out.append("osascript")
+    elif which("zenity") and (os.environ.get("DISPLAY") or
+                              os.environ.get("WAYLAND_DISPLAY")):
+        out.append("zenity")
+    return out
+
+
+def _via_socket(text: str, digest: str, to: float, tags: list[str] | None = None
+                ) -> str | None:
+    p = sock_path()
+    if not p.exists() or not hasattr(socket, "AF_UNIX"):
+        return None
+    s = None
+    try:
+        s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        s.settimeout(to)
+        s.connect(str(p))
+        s.sendall((json.dumps({"text": text, "digest": digest,
+                               "tags": tags or []}) + "\n").encode())
+        buf = b""
+        while b"\n" not in buf:
+            chunk = s.recv(4096)
+            if not chunk:
+                break
+            buf += chunk
+        d = json.loads(buf.decode().strip() or "{}").get("decision")
+        return d if d in (ALLOW, DENY) else None
+    except Exception:
+        return None
+    finally:
+        if s is not None:
+            try:
+                s.close()
+            except OSError:
+                pass
+
+
+def _via_osascript(text: str, digest: str, to: float,
+                   tags: list[str] | None = None) -> str | None:
+    if sys.platform != "darwin" or not which("osascript"):
+        return None
+    body = (text[:1500] + ("…" if len(text) > 1500 else ""))
+    body = body.replace("\\", "\\\\").replace('"', '\\"')
+    script = (
+        f'display dialog "{body}" with title "countersign {digest}" '
+        f'buttons {{"Deny", "Allow"}} default button "Deny" '
+        f'with icon caution giving up after {int(to)}'
+    )
+    try:
+        r = subprocess.run(["osascript", "-e", script], capture_output=True,
+                           text=True, timeout=to + 5)
+        out = (r.stdout or "").strip()
+        compact = out.replace(" ", "")
+        if "gave up:true" in compact:
+            return None
+        if "button returned:Allow" in out:
+            return ALLOW
+        if "button returned:Deny" in out:
+            return DENY
+        return None
+    except Exception:
+        return None
+
+
+def _via_zenity(text: str, digest: str, to: float,
+                tags: list[str] | None = None) -> str | None:
+    if sys.platform == "darwin" or not which("zenity"):
+        return None
+    tagline = (" [" + ",".join(tags) + "]") if tags else ""
+    try:
+        rc = subprocess.run(
+            ["zenity", "--question", f"--title=countersign {digest}{tagline}",
+             f"--text={text}", "--ok-label=Allow", "--cancel-label=Deny",
+             f"--timeout={int(to)}", "--width=520"],
+            timeout=to + 5,
+        ).returncode
+        if rc == 0:
+            return ALLOW
+        if rc == 1:
+            return DENY
+        return None
+    except Exception:
+        return None
+
+
+_BACKENDS = {
+    "socket": _via_socket,
+    "osascript": _via_osascript,
+    "zenity": _via_zenity,
+}