outfence 0.1.0a2__py3-none-any.whl

outfence/__init__.py

@@ -0,0 +1,3 @@
+"""Outfence: local destination policy and connection reports."""
+
+__version__ = "0.1.0a2"

outfence/__main__.py

@@ -0,0 +1,6 @@
+"""Support python -m outfence."""
+
+from .cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

outfence/cli.py

@@ -0,0 +1,253 @@
+"""CLI entry points and POSIX workload lifecycle."""
+
+import argparse
+import json
+import os
+import shutil
+import signal
+import subprocess
+import sys
+import uuid
+from contextlib import nullcontext
+from pathlib import Path
+from urllib.parse import urlsplit
+
+from . import __version__, console
+from .demo import Fixture, demo_requests
+from .modeltap import ModelTap
+from .policy import DEMO_POLICY, load_policy
+from .provenance import Session
+from .proxy import LoopbackHTTPServer, Proxy, Service, now
+from .report import format_report, terminal_text, write_report
+
+
+class Interrupted(Exception):
+    pass
+
+
+def interrupt(signum, frame):
+    raise Interrupted()
+
+
+def model_upstream(value):
+    parsed = urlsplit(value)
+    if (
+        parsed.scheme != "http"
+        or parsed.hostname not in ("127.0.0.1", "localhost", "::1")
+        or not parsed.port
+        or parsed.username is not None
+        or parsed.path not in ("", "/")
+        or parsed.query
+        or parsed.fragment
+    ):
+        raise ValueError(
+            "--model-upstream must be a local model server, e.g. http://127.0.0.1:8080"
+        )
+    return ("127.0.0.1" if parsed.hostname == "localhost" else parsed.hostname), parsed.port
+
+
+def run_workload(cmd, proxy, timeout, extra_env=None):
+    url = f"http://127.0.0.1:{proxy.server_port}"
+    env = dict(os.environ)
+    env.update({k: url for k in ("HTTP_PROXY", "HTTPS_PROXY", "http_proxy", "https_proxy")})
+    env.update(NO_PROXY="", no_proxy="")
+    env.update(extra_env or {})
+    old_handler = signal.signal(signal.SIGTERM, interrupt)
+    proc = None
+    try:
+        proc = subprocess.Popen(cmd, env=env, start_new_session=True)
+        return proc.wait(timeout=timeout), False
+    except (subprocess.TimeoutExpired, KeyboardInterrupt, Interrupted):
+        print("Workload interrupted or timed out; stopping its process group.", file=sys.stderr)
+        return None, True
+    except OSError:
+        print("Could not launch workload. Check the executable and permissions.", file=sys.stderr)
+        return None, True
+    finally:
+        if proc is not None:
+            try:
+                os.killpg(proc.pid, signal.SIGKILL)
+            except ProcessLookupError:
+                pass
+            proc.wait()
+        signal.signal(signal.SIGTERM, old_handler)
+
+
+def parser():
+    result = argparse.ArgumentParser(
+        prog="outfence",
+        description="Inspect proxy-routed connections. A local development tool, not a network sandbox.",
+    )
+    result.add_argument("--version", action="version", version=f"Outfence {__version__}")
+    sub = result.add_subparsers(dest="command", required=True)
+    init = sub.add_parser("init", help="Write a deny-all policy (or --demo policy)")
+    init.add_argument("path", nargs="?", default="outfence.json")
+    init.add_argument("--demo", action="store_true")
+    check = sub.add_parser("check", help="Validate a policy without making connections")
+    check.add_argument("path")
+    for name in ("demo", "run"):
+        p = sub.add_parser(
+            name,
+            help="Run synthetic local requests" if name == "demo" else "Run a proxy-aware command",
+        )
+        p.add_argument("--policy", required=name == "run")
+        p.add_argument("--mode", choices=["enforce", "observe"], default="enforce")
+        p.add_argument("--output", help="New report directory; existing directories are refused")
+        if name == "run":
+            p.add_argument(
+                "--timeout", type=int, default=60, help="Workload timeout in seconds (default: 60)"
+            )
+            p.add_argument(
+                "--model-upstream",
+                metavar="URL",
+                help="Observe chat completions sent to this local OpenAI-compatible model server",
+            )
+            p.add_argument("workload", nargs=argparse.REMAINDER)
+    return result
+
+
+def notice(style, text, alarm=False):
+    if style.enabled:
+        text = "  " + style.paint(text, console.ACID if alarm else style.dim)
+    print(text, flush=True)
+
+
+def welcome(style):
+    """A short menu for people who type `outfence` in a terminal with no arguments."""
+    columns = shutil.get_terminal_size((80, 24)).columns
+    print("\n".join(["", *console.banner(style, f"{__version__} alpha", columns), ""]))
+    choices = [
+        ("1", "Watch Outfence block a request: the offline demo"),
+        ("2", "Run your agent through Outfence"),
+        ("3", "Create a deny-all policy here (outfence.json)"),
+        ("q", "Quit"),
+    ]
+    for key, text in choices:
+        print(f"  {style.paint(key, console.ACID, bold=True)}  {text}")
+    try:
+        choice = input("\n  Choose 1, 2, 3 or q: ").strip().lower()
+    except (EOFError, KeyboardInterrupt):
+        print()
+        return 0
+    if choice == "1":
+        return main(["demo"])
+    if choice == "3":
+        return main(["init"])
+    if choice == "2":
+        print(
+            "\n  Run any proxy-aware command against a policy:\n"
+            "    outfence run --policy outfence.json -- python3 my_agent.py\n\n"
+            "  Add your local model server to see who named each destination:\n"
+            "    outfence run --policy outfence.json --model-upstream http://127.0.0.1:11434"
+            " -- python3 my_agent.py\n"
+        )
+    return 0
+
+
+def main(argv=None):
+    argv = sys.argv[1:] if argv is None else argv
+    if not argv and sys.stdin.isatty() and sys.stdout.isatty():
+        return welcome(console.detect(sys.stdout))
+    args = parser().parse_args(argv)
+    style = console.detect(sys.stdout)
+    try:
+        if args.command == "init":
+            data = DEMO_POLICY if args.demo else {"version": 1, "allow": []}
+            with Path(args.path).open("x", encoding="utf-8") as stream:
+                json.dump(data, stream, indent=2)
+                stream.write("\n")
+            print(f"Policy created: {args.path}")
+            return 0
+        if args.command == "check":
+            policy = load_policy(args.path)
+            sources = ", ".join(policy.get("allow_from", []))
+            named = f"; also hosts named by: {sources}" if sources else ""
+            print(f"Valid policy: {len(policy['allow'])} exact destination rules{named}")
+            return 0
+        if os.name != "posix":
+            raise ValueError("This alpha supports macOS and Linux only.")
+        policy = load_policy(args.policy) if args.policy else DEMO_POLICY
+        upstream = None
+        if args.command == "run":
+            cmd = args.workload[1:] if args.workload[:1] == ["--"] else args.workload
+            if not cmd or args.timeout < 1:
+                raise ValueError("Provide a positive timeout and a command after --.")
+            if args.model_upstream:
+                upstream = model_upstream(args.model_upstream)
+        output = (
+            Path(args.output) if args.output else Path("runs") / ("run-" + uuid.uuid4().hex[:10])
+        )
+        # Validate/reserve the output before starting a potentially side-effectful command.
+        output.mkdir(parents=True, exist_ok=False, mode=0o700)
+        coverage = "proxy + model tap" if upstream else "proxy only"
+        columns = shutil.get_terminal_size((80, 24)).columns
+        honest = "Direct connections can bypass this proxy. No OS/container isolation."
+        if style.enabled:
+            status = f"{__version__} alpha | {args.mode} | {coverage}"
+            print("\n".join(["", *console.banner(style, status, columns), ""]), flush=True)
+        else:
+            print(f"Outfence {__version__}, local proxy alpha, coverage: {coverage}", flush=True)
+        notice(style, honest)
+        if args.mode == "observe":
+            notice(style, "OBSERVE: out-of-policy proxy requests may connect.", alarm=True)
+        if policy.get("allow_from") and not upstream:
+            notice(style, "allow_from needs --model-upstream; only exact allow rules apply.", True)
+        live = console.Live(style, sys.stdout) if style.enabled else None
+        started, incomplete, workload_exit, session = now(), False, 0, None
+        if args.command == "demo":
+            fixture = LoopbackHTTPServer(("127.0.0.1", 0), Fixture)
+            fixture.received = []
+            with Service(fixture):
+                routes = {
+                    (host, 80): fixture.server_address
+                    for host in ("model.example", "retrieval.example", "telemetry.example")
+                }
+                announce = live.decision if live else None
+                with Service(Proxy(policy, args.mode, routes, on_decision=announce)) as proxy:
+                    try:
+                        demo_requests(proxy.server_port)
+                    except (OSError, KeyboardInterrupt):
+                        incomplete = True
+            print(
+                f"  Fixture received {len(fixture.received)} connections (destination-side evidence)."
+            )
+        else:
+            session = Session(on_change=live.change if live else None) if upstream else None
+            announce = live.decision if live else None
+            with (
+                Service(ModelTap(upstream, session)) if upstream else nullcontext() as tap,
+                Service(Proxy(policy, args.mode, session=session, on_decision=announce)) as proxy,
+            ):
+                env = {}
+                if tap is not None:
+                    base = f"http://127.0.0.1:{tap.server_port}/v1"
+                    env = {"OPENAI_BASE_URL": base, "OUTFENCE_MODEL_URL": base}
+                    notice(style, f"Model tap: {base} -> {args.model_upstream}")
+                workload_exit, incomplete = run_workload(cmd, proxy, args.timeout, env)
+        report = write_report(
+            output,
+            args.mode,
+            policy,
+            proxy.snapshot(),
+            started,
+            workload_exit,
+            demo=args.command == "demo",
+            incomplete=incomplete or proxy.incomplete or bool(session and session.errors),
+            reserved=True,
+            dropped_events=proxy.dropped_events,
+            model_tap=session.summary() if session else None,
+        )
+        evidence = terminal_text((output / "report.json").resolve())
+        if style.enabled:
+            print(console.render(style, report, evidence, columns))
+        else:
+            print(format_report(report))
+            print(f"JSON: {evidence}")
+        return report["exit_code"]
+    except (OSError, ValueError) as exc:
+        print(f"Outfence setup error: {exc}", file=sys.stderr)
+        return 3
+
+
+if __name__ == "__main__":
+    sys.exit(main())

outfence/console.py

@@ -0,0 +1,309 @@
+"""Interactive terminal look: brand colors, the Capitoline goose and live decisions.
+
+Styling applies only when stdout is a terminal, or when OUTFENCE_COLOR=always. NO_COLOR,
+OUTFENCE_COLOR=never, pipes, files and CI get the plain report, which carries the same facts.
+"""
+
+import os
+import re
+import threading
+import time
+from datetime import datetime
+
+from .mascot import MARK, POSES
+from .report import EXIT_REASONS, explain, terminal_text
+
+# Copied from brand/tokens.json; tests/test_console.py keeps them identical.
+INK, PAPER, ACID, MIST, SLATE = "#171917", "#FAFAF7", "#D9F378", "#C2C6BC", "#656B63"
+# On dark terminals the outlines turn dark grey and the white body carries the shape.
+DARK_OUTLINE, DARK_SHADOW, LIGHT_SHADOW = "#5A5F58", "#30332F", "#D0D4CB"
+ANSI = re.compile(r"\x1b\[[0-9;]*m")
+GLYPHS = {
+    "o": [".....", ".....", ".###.", "#...#", "#...#", "#...#", ".###."],
+    "u": [".....", ".....", "#...#", "#...#", "#...#", "#..##", ".##.#"],
+    "t": [".#...", ".#...", "####.", ".#...", ".#...", ".#..#", "..##."],
+    "f": ["..###", ".#...", "####.", ".#...", ".#...", ".#...", ".#..."],
+    "e": [".....", ".....", ".###.", "#...#", "#####", "#....", ".###."],
+    "n": [".....", ".....", "####.", "#...#", "#...#", "#...#", "#...#"],
+    "c": [".....", ".....", ".###.", "#...#", "#....", "#...#", ".###."],
+}
+LABELS = {"allowed": "ALLOWED", "blocked": "BLOCKED", "would_block": "WOULD BLOCK"}
+WIDTH = 13
+
+
+def xterm(r, g, b):
+    """Nearest xterm-256 color, for terminals without 24-bit color."""
+    if max(r, g, b) - min(r, g, b) < 16:
+        level = (r + g + b) // 3
+        return 16 if level < 8 else 231 if level > 247 else 232 + (level - 8) // 10
+    return 16 + 36 * round(r / 51) + 6 * round(g / 51) + round(b / 51)
+
+
+class Style:
+    def __init__(self, enabled=False, truecolor=True, light=False):
+        self.enabled, self.truecolor, self.light = enabled, truecolor, light
+        self.text = INK if light else PAPER
+        self.dim = SLATE if light else MIST
+
+    def color(self, hex_color, layer):
+        r, g, b = (int(hex_color[i : i + 2], 16) for i in (1, 3, 5))
+        if self.truecolor:
+            return f"\x1b[{layer};2;{r};{g};{b}m"
+        return f"\x1b[{layer};5;{xterm(r, g, b)}m"
+
+    def paint(self, text, fg=None, bg=None, bold=False):
+        if not self.enabled:
+            return text
+        codes = (self.color(fg, 38) if fg else "") + (self.color(bg, 48) if bg else "")
+        codes += "\x1b[1m" if bold else ""
+        return f"{codes}{text}\x1b[0m" if codes else text
+
+    def palette(self, art):
+        if art == "mark":
+            return (
+                {"k": INK, "w": PAPER, "a": ACID}
+                if self.light
+                else {"k": PAPER, "w": INK, "a": ACID}
+            )
+        if self.light:
+            return {"k": INK, "w": PAPER, "a": ACID, "s": LIGHT_SHADOW}
+        return {"k": DARK_OUTLINE, "w": PAPER, "a": ACID, "s": DARK_SHADOW}
+
+
+def detect(stream, environ=None):
+    environ = os.environ if environ is None else environ
+    choice = environ.get("OUTFENCE_COLOR", "auto").lower()
+    tty = getattr(stream, "isatty", lambda: False)()
+    if environ.get("NO_COLOR") or choice == "never":
+        return Style()
+    if choice != "always" and (not tty or environ.get("TERM") == "dumb"):
+        return Style()
+    truecolor = environ.get("COLORTERM", "").lower() in ("truecolor", "24bit")
+    theme = environ.get("OUTFENCE_THEME", "").lower()
+    background = environ.get("COLORFGBG", "").rsplit(";", 1)[-1]
+    return Style(
+        True, truecolor, theme == "light" or (theme != "dark" and background in ("7", "15"))
+    )
+
+
+def visible(text):
+    return len(ANSI.sub("", text))
+
+
+def decode(art):
+    return [
+        "".join(c * int(n or 1) for n, c in re.findall(r"(\d*)([kwas.])", row))
+        for row in art.split("|")
+    ]
+
+
+def crop(rows):
+    used = [i for i, row in enumerate(rows) if set(row) != {"."}]
+    cols = [j for j in range(len(rows[0])) if any(row[j] != "." for row in rows)]
+    return [row[cols[0] : cols[-1] + 1] for row in rows[used[0] : used[-1] + 1]]
+
+
+def pixels(style, rows, palette):
+    """Two tile rows per line: the upper half block takes the foreground, the lower the background."""
+    if len(rows) % 2:
+        rows = rows + ["." * len(rows[0])]
+    lines = []
+    for top, bottom in zip(rows[0::2], rows[1::2]):
+        cells = []
+        for a, b in zip(top, bottom):
+            if a == b == ".":
+                cells.append((" ", None, None))
+            elif b == ".":
+                cells.append(("▀", palette[a], None))
+            elif a == ".":
+                cells.append(("▄", palette[b], None))
+            else:
+                cells.append(("▀", palette[a], palette[b]))
+        line, start = "", 0
+        for index in range(1, len(cells) + 1):
+            if index == len(cells) or cells[index][1:] != cells[start][1:]:
+                text = "".join(cell[0] for cell in cells[start:index])
+                line += style.paint(text, *cells[start][1:]) if cells[start][1] else text
+                start = index
+        lines.append(line.rstrip())
+    return lines
+
+
+def wordmark(style):
+    rows = [""] * 7
+    for index, letter in enumerate("outfence"):
+        rows = [row + ("." if index else "") + glyph for row, glyph in zip(rows, GLYPHS[letter])]
+    return pixels(style, [row.replace("#", "k") for row in rows], {"k": style.text})
+
+
+def side_by_side(left, right, gap=3):
+    width = max((visible(line) for line in left), default=0)
+    height = max(len(left), len(right))
+    left, right = left + [""] * (height - len(left)), right + [""] * (height - len(right))
+    return [f"  {a}{' ' * (width - visible(a) + gap)}{b}".rstrip() for a, b in zip(left, right)]
+
+
+def banner(style, status, columns):
+    if columns < 72:
+        return [
+            f"  {style.paint('outfence', style.text, bold=True)}  {style.paint(status, style.dim)}"
+        ]
+    right = wordmark(style) + [
+        style.paint("Know where your agents connect.", style.dim),
+        style.paint(status, style.dim),
+    ]
+    return side_by_side(pixels(style, decode(MARK), style.palette("mark")), right)
+
+
+def label(style, action):
+    word = LABELS.get(action, terminal_text(action).upper())
+    if action == "blocked":
+        return style.paint(f" {word} ", INK, ACID, bold=True) + " " * (WIDTH - len(word) - 2)
+    if action == "would_block":
+        return style.paint(word.ljust(WIDTH), ACID, bold=True)
+    return style.paint(word.ljust(WIDTH), style.dim)
+
+
+def destination(event):
+    host = event["host"] or "unknown"
+    return terminal_text(
+        f"[{host}]:{event['port']}" if ":" in host else f"{host}:{event['port'] or '?'}"
+    )
+
+
+class Live:
+    """Prints decisions and tool changes as they happen. Proxy and tap threads call it."""
+
+    def __init__(self, style, stream):
+        self.style, self.stream, self.lock = style, stream, threading.Lock()
+
+    def line(self, kind, text):
+        stamp = self.style.paint(time.strftime("%H:%M:%S"), self.style.dim)
+        with self.lock:
+            print(f"  {stamp}  {kind}{text}", file=self.stream, flush=True)
+
+    def decision(self, event):
+        reason = self.style.paint(terminal_text(event["reason"]), self.style.dim)
+        self.line(label(self.style, event["action"]), f"{destination(event)}  {reason}")
+
+    def change(self, note):
+        kind = self.style.paint(note["kind"].replace("_", " ").ljust(WIDTH), self.style.dim)
+        if note["kind"] == "tools":
+            names = [f"+{n}" for n in note["added"]] + [f"-{n}" for n in note["removed"]]
+            self.line(kind, terminal_text(" ".join(names)))
+        else:
+            hosts = self.style.paint(terminal_text(", ".join(note["hosts"])), self.style.dim)
+            self.line(kind, f"{terminal_text(note['name'] or 'unnamed')}  {hosts}")
+
+
+def pose_for(report):
+    actions = {event["action"] for event in report["events"]}
+    if "blocked" in actions:
+        return "blocking"
+    if "would_block" in actions or report["exit_code"] == 3:
+        return "alarm"
+    return "approving" if report["events"] else "idle"
+
+
+def plural(count, word):
+    return f"{count} {word}{'' if count == 1 else 's'}"
+
+
+def headline(style, report):
+    events = report["events"]
+    blocked = sum(e["action"] == "blocked" for e in events)
+    would = sum(e["action"] == "would_block" for e in events)
+    model = sum(e.get("origin") == "model" and e["action"] != "allowed" for e in events)
+    by_model = f", {model} named only by the model" if model else ""
+    if blocked:
+        return f"{label(style, 'blocked')}{plural(blocked, 'destination')} outside your policy{by_model}"
+    if would:
+        text = f"{plural(would, 'destination')} outside your policy, let through by observe mode"
+        return f"{label(style, 'would_block')}{text}{by_model}"
+    if report["exit_code"] == 3:
+        return f"{style.paint('INCOMPLETE'.ljust(WIDTH), ACID, bold=True)}evidence may be missing"
+    if events:
+        return (
+            f"{label(style, 'allowed')}{plural(len(events), 'destination')}, all within your policy"
+        )
+    return f"{style.paint('IDLE'.ljust(WIDTH), style.dim)}no proxy requests observed"
+
+
+def render(style, report, evidence, columns, environ=None):
+    """The styled report: the same facts as format_report, plus the goose for the outcome."""
+    environ = os.environ if environ is None else environ
+    dim = style.dim
+    events, tap, coverage = report["events"], report.get("model_tap"), report["coverage"]
+    counts = {
+        a: sum(e["action"] == a for e in events) for a in ("allowed", "blocked", "would_block")
+    }
+    exit_code = report["exit_code"]
+    workload = report["workload_exit_code"]
+    summary = [
+        "",
+        headline(style, report),
+        "",
+        f"allowed {counts['allowed']} | blocked {counts['blocked']} | would block {counts['would_block']}",
+        style.paint(
+            f"mode {report['mode']} | coverage {coverage['status']}"
+            f" | provenance {coverage.get('provenance', 'unavailable')}",
+            dim,
+        ),
+        "",
+        f"{style.paint(f'Exit {exit_code}', style.text, bold=True)}  {EXIT_REASONS[exit_code]}",
+        style.paint(
+            f"workload exit {workload if workload is not None else 'unavailable'}"
+            " | task correctness not evaluated",
+            dim,
+        ),
+        style.paint(f"evidence {evidence}", dim),
+    ]
+    goose = []
+    if environ.get("OUTFENCE_GOOSE", "on").lower() not in ("off", "0", "no"):
+        goose = pixels(style, crop(decode(POSES[pose_for(report)])), style.palette("pose"))
+    width = max((visible(line) for line in goose), default=0)
+    if goose and columns >= width + 5 + max(visible(line) for line in summary):
+        lines = side_by_side(goose, summary)
+    elif goose and columns >= width + 4:
+        lines = [f"  {line}" for line in goose] + [f"  {line}" for line in summary]
+    else:
+        lines = [f"  {line}" for line in summary]
+    lines.append("")
+    if tap is not None:
+        lines.append(
+            "  "
+            + style.paint("model tap".ljust(WIDTH), dim)
+            + f"{plural(tap['requests'], 'chat request')} | {plural(len(tap['tool_calls']), 'tool call')}"
+            + f" | {tap['rejected']} rejected | {tap['errors']} errors"
+        )
+        for change in tap["environment"]:
+            names = [f"+{n}" for n in change["added"]] + [f"-{n}" for n in change["removed"]]
+            if names:
+                when = datetime.fromisoformat(change["time"]).astimezone().strftime("%H:%M:%S")
+                kind = style.paint("tools".ljust(WIDTH), dim)
+                lines.append(f"  {kind}{when}  {terminal_text(' '.join(names))}")
+        lines.append("")
+    for event in events:
+        reason = f"{terminal_text(event['reason'])} | {terminal_text(event['connection'])}"
+        lines.append(
+            f"  {label(style, event['action'])}{destination(event)}  {style.paint(reason, dim)}"
+        )
+        lines.extend(" " * (WIDTH + 2) + style.paint(line.strip(), dim) for line in explain(event))
+    if not events:
+        lines.append(
+            "  "
+            + style.paint(
+                "No proxy requests observed. This does not prove there was no network activity.",
+                dim,
+            )
+        )
+    lines += [
+        "",
+        "  "
+        + style.paint(
+            f"Dropped events: {coverage['dropped_events']}. Direct connections bypass this proxy."
+            " Encrypted contents are not inspected.",
+            dim,
+        ),
+    ]
+    return "\n".join(lines)

outfence/core.py

@@ -0,0 +1,7 @@
+"""Compatibility imports for early prototype users. Prefer dedicated modules."""
+
+from .policy import load_policy
+from .proxy import Proxy, Service, now
+from .report import write_report
+
+__all__ = ["load_policy", "Proxy", "Service", "now", "write_report"]

outfence/demo.py

@@ -0,0 +1,30 @@
+"""Synthetic services used only by demo and offline tests."""
+
+import http.client
+from http.server import BaseHTTPRequestHandler
+
+
+class Fixture(BaseHTTPRequestHandler):
+    def log_message(self, *args):
+        pass
+
+    def do_GET(self):
+        self.server.received.append(self.headers.get("Host"))
+        body = b'{"ok":true,"fixture":"local synthetic service"}\n'
+        self.send_response(200)
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+
+
+def demo_requests(port):
+    statuses = []
+    for host in ("model.example", "retrieval.example", "telemetry.example"):
+        conn = http.client.HTTPConnection("127.0.0.1", port, timeout=5)
+        conn.request("GET", f"http://{host}/demo")
+        response = conn.getresponse()
+        statuses.append(response.status)
+        response.read()
+        conn.close()
+        print(f"  {host:24} HTTP {response.status}")
+    return statuses

outfence/mascot.py

@@ -0,0 +1,14 @@
+"""Capitoline goose tile art for the terminal, copied from brand/mascot.json.
+
+Rows are run-length encoded and separated by |: k ink, w white, a acid, s shadow, . empty.
+tests/test_console.py keeps this copy identical to the brand file.
+"""
+
+MARK = "3.k.k.k6.|4.3k7.|3.6k5.|2.8k4.|2.6kw2k3.|2.9k3a|2.9k2a.|3.7k4.|3.6k5.|3.4k7.|2.5k7.|2.4k8.|.5k8.|.4k9."
+POSES = {
+    "watching": "66.|66.|66.|66.|38.k2.k24.|36.k2.k.k24.|37.2k.k25.|38.k.2k24.|38.6k22.|37.2k4w2k21.|36.2k6w2k20.|36.2k4wkw5a17.|36.k7w6a16.|36.k7w7a15.|35.3k6w5a17.|35.4k4w2k21.|34.2kw8k21.|34.2k3w4k23.|34.k5w2k24.|34.k5wk25.|33.2k4w2k25.|33.2k4w2k25.|33.2k4w2k25.|33.2k4wk26.|33.2k4wk26.|33.2k4wk26.|24.10k5wk26.|7.2k11.16k3wk26.|7.3k8.4k12w4kwk26.|8.3k3.5k18w3k26.|8.4k2.18k6w3k25.|8.2kw14k5w4k5w2k25.|9.k2w5k16w2k5w2k24.|9.2kw2k2w2k16wk5w2k24.|10.3k3w3k15w2k5wk24.|11.2k4w3k14w2k4w2k24.|11.2k6w2k13w2k4w2k24.|11.2k7w5k7w3k4w2k25.|12.k9w12k4w2k26.|12.2k23w2k27.|13.2k21w2k28.|14.3k16w4k29.|16.4k10w5k31.|18.14k34.|23.2k4.2k35.|24.k4.2k35.|23.ka4.2k35.|23.4a2.4a33.|11.12s4a2s5a11s21.|15.27s24.|66.|66.|66.",
+    "alarm": "66.|66.|66.|66.|38.k2.k24.|36.k2.k.k24.|37.2k.k25.|38.k.2k24.|38.6k22.|37.2k4w2k14.a6.|36.2k6w2k14.a5.|36.2k4wkw4a9.a2.a5.|36.k7w6a7.a2.a5.|36.k8w5a7.a2.a5.|35.3k6w2k11.a2.a5.|35.4k4wk6a7.a2.a5.|34.2kw7k.3a9.a2.a5.|34.2k3w4k17.a5.|34.k5w2k17.a6.|34.k5wk25.|33.2k4w2k25.|33.2k4w2k25.|33.2k4w2k25.|33.2k4wk26.|33.2k4wk26.|33.2k4wk26.|24.10k5wk26.|7.2k11.16k3wk26.|7.3k8.4k12w4kwk26.|8.3k3.5k18w3k26.|8.4k2.18k6w3k25.|8.2kw14k5w4k5w2k25.|9.k2w5k16w2k5w2k24.|9.2kw2k2w2k16wk5w2k24.|10.3k3w3k15w2k5wk24.|11.2k4w3k14w2k4w2k24.|11.2k6w2k13w2k4w2k24.|11.2k7w5k7w3k4w2k25.|12.k9w12k4w2k26.|12.2k23w2k27.|13.2k21w2k28.|14.3k16w4k29.|16.4k10w5k31.|18.14k34.|23.2k4.2k35.|24.k4.2k35.|23.ka4.2k35.|23.4a2.4a33.|11.12s4a2s5a11s21.|15.27s24.|66.|66.|66.",
+    "blocking": "66.|66.|66.|66.|66.|66.|66.|66.|66.|66.|66.|66.|66.|66.|66.|66.|19.2k45.|18.5k43.|18.2kw3k42.|18.k4w3k40.|18.kw2k3w2k39.|17.2k3wk3w2k38.|17.2k4w2k2w2k21.k15.|17.2k6wk2w2k18.k.k15.|17.2k7w2kw2k14.k3.k16.|17.k10wkw2k15.k.k16.|17.k12w2k15.6k10.k2.|17.k13w2k13.2k4w2k7.2k3.|6.2k7.4k12w3k8.5k6w2a11.|6.3k4.3kw2k13w15k3w2kw5a8.|6.5k.2k3w3k12w5k8w2k6w6a7.|7.k2w3k5w7k3w5k3w2k7w2k6w2k11.|7.2kw2k9w10k6w2k7w2k4wk6a7.|8.kw2k26wk7w3k2w2k4a9.|8.3k27w14k9.2k3.|9.3k27w2k22.k2.|10.2k27wk26.|11.2k25w2k26.|11.2k25wk27.|12.3k22w2k27.|14.2k19w3k28.|15.4k14w4k29.|17.7k5w6k31.|20.12k34.|20.k9.k35.|19.2k9.2k34.|19.2k9.2k34.|18.3a9.s3a32.|8.9s5a9s5a9s21.|12.29s25.|66.|66.|66.",
+    "approving": "66.|66.|66.|66.|38.k2.k24.|36.k2.k.k24.|37.2k.k25.|38.k.2k24.|38.6k22.|37.2k4w2k21.|36.2k6w2k20.|36.2k4wkw5a17.|36.k7w6a16.|36.k7w7a15.|35.3k6w5a17.|35.4k4w2k21.|34.2kw8k21.|34.2k3w4k23.|34.k5w2k24.|34.k5wk17.2k6.|33.2k4w2k17.k7.|33.2k4w2k16.k8.|33.2k4w2k15.2k8.|33.2k4wk9.2k4.2k9.|33.2k4wk10.2k3.k10.|33.2k4wk11.2k.k11.|24.10k5wk12.2k12.|7.2k11.16k3wk13.k12.|7.3k8.4k12w4kwk26.|8.3k3.5k18w3k26.|8.4k2.18k6w3k25.|8.2kw14k5w4k5w2k25.|9.k2w5k16w2k5w2k24.|9.2kw2k2w2k16wk5w2k24.|10.3k3w3k15w2k5wk24.|11.2k4w3k14w2k4w2k24.|11.2k6w2k13w2k4w2k24.|11.2k7w5k7w3k4w2k25.|12.k9w12k4w2k26.|12.2k23w2k27.|13.2k21w2k28.|14.3k16w4k29.|16.4k10w5k31.|18.14k34.|23.2k4.2k35.|24.k4.2k35.|23.ka4.2k35.|23.4a2.4a33.|11.12s4a2s5a11s21.|15.27s24.|66.|66.|66.",
+    "idle": "66.|66.|66.|66.|66.|66.|66.|66.|66.|66.|66.|66.|66.|66.|66.|66.|39.k26.|36.2k2.k.k23.|38.k.k.k23.|39.4k23.|38.7k21.|37.2k5w2k20.|37.k6w2k20.|36.2k4wkw4a18.|36.2k6w6a16.|36.2k6w6a16.|36.2k6wk3a18.|35.5k3w2k21.|35.k2w6k22.|35.k4w2k24.|35.k4w2k24.|35.k4w2k24.|35.k4w2k24.|35.k4w2k24.|26.10k4w2k24.|9.k5.k5.18kw2k24.|9.2k4.18k4w5k24.|9.4k2.11k5w4k5w3k23.|9.2kw6k16w2k6w2k22.|10.2kw3kw2k16wk7w2k21.|10.2kwk3w3k15w2k6w2k21.|11.3k4w3k14w2k6w2k21.|12.2k6w2k13w2k6w2k21.|12.2k7w5k7w3k6w2k22.|13.2k8w12k6w2k23.|14.2k23w3k24.|15.4k17w4k26.|17.7k6w8k28.|11.10s13k14s18.|15.29s22.|66.|66.|66.",
+}