relayloom 0.3.0__py3-none-any.whl

relayloom/__init__.py

@@ -0,0 +1,3 @@
+"""Relayloom: accounts payable that checks the goods, not just the paperwork."""
+
+__version__ = "0.3.0"

relayloom/__main__.py

@@ -0,0 +1,39 @@
+"""Start Relayloom. Rehearsal is the default; Meta requires explicit opt-in."""
+import argparse
+from pathlib import Path
+
+from .controller import Controller
+from .server import LocalServer
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--port", type=int, default=8800)
+    parser.add_argument("--database", type=Path, default=Path("data/relayloom.sqlite3"))
+    parser.add_argument("--enable-meta-synthetic", action="store_true", help="Allow billable Meta calls only after explicit environment configuration; synthetic fixture only")
+    args = parser.parse_args()
+    if not 1 <= args.port <= 65535:
+        parser.error("port must be between 1 and 65535")
+    if args.enable_meta_synthetic:
+        from .meta import MetaWorker
+        try:
+            worker = MetaWorker.from_environment()
+        except (ValueError, OSError) as error:
+            parser.error(str(error))
+        controller = Controller(args.database, worker=worker)
+    else:
+        controller = Controller(args.database)
+    server = LocalServer(("127.0.0.1", args.port), controller)
+    print(f"Relayloom {controller.mode} mode: http://127.0.0.1:{args.port}")
+    print("Synthetic specialist outputs. No live inference or external actions." if controller.mode == "rehearsal" else "Meta enabled for the bundled fictional fixture. Run specialists may consume credits. No external actions.")
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        pass
+    finally:
+        server.server_close()
+        controller.close()
+
+
+if __name__ == "__main__":
+    main()

relayloom/ap/__main__.py

@@ -0,0 +1,3 @@
+from .app import main
+
+main()

relayloom/ap/alerts.py

@@ -0,0 +1,228 @@
+"""Alerts to a phone on the same local network. Nothing leaves the building and no internet is needed.
+
+AlertHub keeps the alerts the agents raise (a delivery needs the owner, the network was cut, hidden text tried to change
+a bank account, a readback failed). PhoneServer is a separate, tiny, read only server that starts only when asked
+(`--phone`). It shows the alerts on a phone page and nothing else: no approvals, no bills, no ledger. Every request needs
+the random token that is printed when it starts, compared in constant time. The main app stays on loopback.
+"""
+from __future__ import annotations
+
+import hmac
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+import json
+import secrets
+import socket
+import threading
+import time
+from urllib.parse import parse_qs, urlsplit
+
+from . import i18n
+from .phone_page import page
+
+
+class AlertHub:
+    def __init__(self):
+        self.items: list[dict] = []
+        self.changed = threading.Condition()
+
+    def publish(self, kind: str, title: str, body: str, case: str = "", key: str = "", params: dict | None = None) -> dict:
+        with self.changed:
+            item = {"id": len(self.items) + 1, "time": time.strftime("%H:%M:%S"), "kind": kind, "title": title,
+                    "body": body, "case": case, "key": key, "params": params or {}}
+            self.items.append(item)
+            self.changed.notify_all()
+            return item
+
+    def after(self, last_id: int, wait: float = 0.0) -> list[dict]:
+        """Alerts newer than last_id. Waits up to `wait` seconds for one to arrive (long polling)."""
+        with self.changed:
+            if wait and not [i for i in self.items if i["id"] > last_id]:
+                self.changed.wait(timeout=wait)
+            return [i for i in self.items if i["id"] > last_id]
+
+
+def lan_address() -> str:
+    """This machine's address on the local network. Connecting a UDP socket sends no packet."""
+    probe = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    try:
+        probe.connect(("10.255.255.255", 1))
+        return probe.getsockname()[0]
+    except OSError:
+        return "127.0.0.1"
+    finally:
+        probe.close()
+
+
+def lan_addresses() -> list[str]:
+    """Every address a phone on a connected network could use, the default route first. A laptop on Wi-Fi and a USB cable has two."""
+    first = lan_address()
+    found = []
+    try:
+        for info in socket.getaddrinfo(socket.gethostname(), None, socket.AF_INET):
+            ip = info[4][0]
+            if not ip.startswith(("127.", "169.254.")):
+                found.append(ip)
+    except OSError:
+        pass
+    ordered = ([first] if first != "127.0.0.1" else []) + [ip for ip in dict.fromkeys(found) if ip != first]
+    return ordered or [first]
+
+
+def announce(server: "PhoneServer") -> None:
+    """Print the phone links, one per network, and a QR code for each so a phone camera can scan it."""
+    print("Phone alerts, local network only, read only. Open the link that is on the SAME network as the phone,")
+    print("or scan its QR code with the phone camera. Anyone with a link sees the alerts, so keep it to yourself.", flush=True)
+    for ip in lan_addresses():
+        link = server.link(ip)
+        print(f"\n  {link}", flush=True)
+        try:
+            import segno
+            segno.make(link, error="m").terminal(compact=False, border=2)  # colour blocks made of spaces: safe on any console encoding
+        except ImportError:
+            print("  (install segno with: python -m pip install segno, to get a QR code here)", flush=True)
+        except Exception:  # a QR code that cannot be drawn never stops the alerts
+            print("  (the QR code could not be drawn in this window, use the link above)", flush=True)
+
+
+
+
+
+IMAGE_TYPES = {"image/jpeg": bytes([0xFF, 0xD8, 0xFF]), "image/png": bytes([0x89]) + b"PNG", "image/webp": b"RIFF"}
+
+
+class PhoneHandler(BaseHTTPRequestHandler):
+    server_version = "RelayloomPhone"
+
+    def log_message(self, format, *args):  # quiet: no tokens in logs
+        pass
+
+    def reply(self, status: int, kind: str, body: bytes):
+        self.send_response(status)
+        self.send_header("Content-Type", kind)
+        self.send_header("Content-Length", str(len(body)))
+        self.send_header("Cache-Control", "no-store")
+        self.send_header("X-Content-Type-Options", "nosniff")
+        self.send_header("Content-Security-Policy", "default-src 'none'; style-src 'unsafe-inline'; script-src 'unsafe-inline'; connect-src 'self'")
+        try:
+            self.end_headers()
+            self.wfile.write(body)
+        except (ConnectionError, OSError):  # the phone went away while waiting; nothing to report
+            self.close_connection = True
+
+    def do_GET(self):
+        url = urlsplit(self.path)
+        query = parse_qs(url.query)
+        given = (query.get("t") or [""])[0]
+        if not hmac.compare_digest(given.encode(), self.server.token.encode()):
+            return self.reply(403, "text/plain; charset=utf-8", b"forbidden")
+        if url.path == "/":
+            return self.reply(200, "text/html; charset=utf-8", page().encode())
+        if url.path == "/alerts":
+            try:
+                last = int((query.get("after") or ["0"])[0])
+            except ValueError:
+                last = 0
+            items = self.server.hub.after(last, wait=self.server.wait)
+            return self.reply(200, "application/json", json.dumps(items).encode())
+        self.reply(404, "text/plain; charset=utf-8", b"not found")
+
+    def do_POST(self):  # read only, except one thing: a photo of the goods, counted on the laptop
+        url = urlsplit(self.path)
+        query = parse_qs(url.query)
+        if url.path != "/photo" or not hmac.compare_digest((query.get("t") or [""])[0].encode(), self.server.token.encode()):
+            self.drain()
+            return self.reply(405 if url.path != "/photo" else 403, "text/plain; charset=utf-8", b"read only" if url.path != "/photo" else b"forbidden")
+        handler = self.server.photo_handler
+        if handler is None:
+            self.drain()
+            return self.json_reply(404, {"error": "This laptop is not taking photos"})
+        kind = (self.headers.get("Content-Type") or "").split(";")[0].strip().lower()
+        try:
+            length = int(self.headers.get("Content-Length") or "")
+        except ValueError:
+            return self.json_reply(411, {"error": "Length required"})
+        if length <= 0 or length > self.server.max_photo:
+            self.close_connection = True
+            return self.json_reply(413, {"error": f"Photo must be under {self.server.max_photo // 1048576} MB"})
+        body = self.rfile.read(length)
+        if kind not in IMAGE_TYPES or not body.startswith(IMAGE_TYPES[kind]):
+            return self.json_reply(415, {"error": "Only JPEG, PNG or WebP photos are accepted"})
+        word = (query.get("word") or ["box"])[0]
+        self.json_reply(202, handler(body, kind, word))
+
+    def drain(self):
+        """Read (and drop) a small refused body, so the client sees the answer instead of a reset connection."""
+        try:
+            remaining = min(int(self.headers.get("Content-Length") or 0), 1048576)
+        except ValueError:
+            return
+        while remaining > 0:
+            chunk = self.rfile.read(min(remaining, 65536))
+            if not chunk:
+                break
+            remaining -= len(chunk)
+
+    def json_reply(self, status: int, value: dict):
+        self.reply(status, "application/json", json.dumps(value).encode())
+
+
+class PhoneServer(ThreadingHTTPServer):
+    daemon_threads = True
+    allow_reuse_address = False  # on Windows reuse lets a second copy share the port and answer with a different token
+
+    def __init__(self, address, hub: AlertHub, token: str | None = None, wait: float = 20.0, photo_handler=None,
+                 max_photo: int = 12 * 1048576):
+        self.hub, self.token, self.wait = hub, token or secrets.token_urlsafe(16), wait
+        self.photo_handler, self.max_photo = photo_handler, max_photo
+        super().__init__(address, PhoneHandler)
+
+    def start(self) -> threading.Thread:
+        thread = threading.Thread(target=self.serve_forever, daemon=True, name="phone-alerts")
+        thread.start()
+        return thread
+
+    def link(self, host: str) -> str:
+        return f"http://{host}:{self.server_address[1]}/?t={self.token}"
+
+
+class PhoneInbox:
+    """Takes photos from the phone, saves them on this laptop, counts them in the background, and alerts with the result.
+
+    `counter.count(photo, prompt, key)` is the same interface the pipeline uses, so SAM 3.1 or the look agent both fit.
+    Nothing leaves the local network: the photo goes phone to laptop, and the count is shown on the phone page.
+    """
+
+    def __init__(self, folder, hub: AlertHub, counter=None):
+        from pathlib import Path
+        self.folder, self.hub, self.counter, self.threads = Path(folder), hub, counter, []
+
+    def __call__(self, body: bytes, kind: str, word: str) -> dict:
+        import re
+        word = word.strip().lower()
+        if not re.fullmatch(r"[a-z][a-z \-]{1,30}", word):
+            word = "box"
+        self.folder.mkdir(parents=True, exist_ok=True)
+        name = time.strftime("dock-%Y%m%d-%H%M%S") + f"-{secrets.token_hex(2)}" + {"image/jpeg": ".jpg", "image/png": ".png", "image/webp": ".webp"}[kind]
+        path = self.folder / name
+        path.write_bytes(body)
+        self.say("photo", "a.photo_received", name=name, kb=len(body) // 1024, word=word)
+        if self.counter is None:
+            self.say("photo", "a.photo_saved")
+        else:
+            thread = threading.Thread(target=self.count, args=(path, word), daemon=True, name="phone-count")
+            thread.start()
+            self.threads.append(thread)
+        return {"received": name, "word": word, "counting": self.counter is not None}
+
+    def say(self, kind: str, key: str, **params):
+        made = i18n.alert(kind, key, **params)
+        self.hub.publish(kind, made["title"], made["body"], "phone", key, made["params"])
+
+    def count(self, path, word: str):
+        try:
+            started = time.perf_counter()
+            result = self.counter.count(path, word, path.stem)
+            seconds = round(time.perf_counter() - started, 1)
+            self.say("counted", "a.counted", n=result["count"], word=word, name=path.name, s=seconds)
+        except Exception as error:  # a failed count is an alert, never a silent miss
+            self.say("readback", "a.count_failed", name=path.name, error=str(error)[:120])

relayloom/ap/app.py

@@ -0,0 +1,244 @@
+"""Relayloom accounts payable: the local app. Loopback only.
+
+python -m relayloom.ap                      recorded mode: recorded Meta model outputs, built in ledger
+python -m relayloom.ap --live               Muse Glimmer and SAM 3.1 on this machine, ERPNext from .env
+Mix with --reader, --counter and --ledger. The screen and every receipt say which ran.
+"""
+from __future__ import annotations
+
+import argparse
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+import json
+import mimetypes
+import os
+from pathlib import Path
+import threading
+import time
+from urllib.parse import parse_qs, urlsplit
+
+from .ledger import ERPNextLedger, LocalLedger
+from .models import GlimmerClient, RecordedGlimmer, SamCounter
+from .pipeline import Network, Workbench
+from .policy import Refused, load_policy
+from .portal import BrowserDisputer, Portal
+from .receipts import ReceiptChain, Signer, verify
+
+ROOT = Path(__file__).resolve().parents[2]
+WEB = ROOT / "web" / "ap"
+FIXTURES = ROOT / "fixtures"
+MAX_BODY = 4096
+
+
+def load_env(path: Path = ROOT / ".env"):
+    """Read KEY=value lines into the environment without printing anything."""
+    if not path.exists():
+        return
+    for line in path.read_text(encoding="utf-8").splitlines():
+        name, sep, value = line.partition("=")
+        if sep and name.strip() and not name.startswith("#") and value.strip():
+            os.environ.setdefault(name.strip(), value.strip())
+
+
+def build(args) -> tuple[Workbench, dict]:
+    data = json.loads((FIXTURES / "data.json").read_text(encoding="utf-8"))
+    run_dir = Path(args.data) / time.strftime("run-%Y%m%d-%H%M%S")
+    run_dir.mkdir(parents=True, exist_ok=True)
+    policy = load_policy()
+    signer = Signer(Path(args.data) / "receipt-signing.key")
+    chain = ReceiptChain(run_dir / "receipts.jsonl", signer, policy.hash)
+    if args.reader == "live":
+        reader = GlimmerClient(os.environ.get("GLIMMER_URL", "http://127.0.0.1:8082/v1"),
+                               os.environ.get("GLIMMER_ROUTE", "Muse Glimmer 30B Q4_K_M, llama.cpp CPU, this machine"))
+    else:
+        reader = RecordedGlimmer()
+    counter = SamCounter(os.environ.get("RELAYLOOM_SAM_PYTHON", ""), os.environ.get("RELAYLOOM_SAM_WEIGHTS", ""),
+                         os.environ.get("SAM_ROUTE", "SAM 3.1 (sam3.1_multiplex.pt), Ultralytics, CPU, this laptop"),
+                         live=args.counter == "live")
+    if args.ledger == "erpnext":
+        def erp():
+            return ERPNextLedger(os.environ.get("ERPNEXT_URL", "http://localhost:8080"), os.environ["ERPNEXT_API_KEY"],
+                                 os.environ["ERPNEXT_API_SECRET"], os.environ.get("ERPNEXT_COMPANY", data["company"]["name"]))
+        ledger, checker = erp(), erp()  # the Checker uses its own client and its own requests
+        data["tax_account"] = os.environ.get("ERPNEXT_TAX_ACCOUNT", "")
+    else:
+        ledger = LocalLedger(run_dir / "local-ledger.sqlite3")
+        ledger.seed(data["suppliers"], data["purchase_orders"], data["history_invoices"])
+        checker = LocalLedger(run_dir / "local-ledger.sqlite3")
+    portal_server = Portal(args.portal_port).start()
+    disputer = BrowserDisputer(f"http://127.0.0.1:{args.portal_port}", run_dir / "media")
+    network = Network(ledger, checker, disputer)
+    bench = Workbench(policy, ledger, checker, chain, reader, counter, network, FIXTURES, data, portal=disputer)
+    run = {"started": time.strftime("%Y-%m-%d %H:%M %z"), "dir": run_dir.name, "ledger": ledger.name,
+           "reader": "Muse Glimmer (live)" if args.reader == "live" else "Muse Glimmer (recorded outputs)",
+           "counter": "SAM 3.1 (live)" if args.counter == "live" else "SAM 3.1 (recorded outputs)",
+           "mode": "live" if args.reader == args.counter == "live" else "recorded" if args.reader == args.counter == "recorded" else "mixed",
+           "public_key": signer.public_key, "policy_hash": policy.hash}
+    (run_dir / "run.json").write_text(json.dumps(run, indent=1), encoding="utf-8")
+    bench.portal_server = portal_server
+    bench.run_dir = run_dir
+    return bench, run
+
+
+class App(ThreadingHTTPServer):
+    daemon_threads = True
+
+    def __init__(self, address, bench: Workbench, run: dict):
+        if address[0] != "127.0.0.1":
+            raise ValueError("bind to loopback only")
+        self.bench, self.run = bench, run
+        super().__init__(address, Handler)
+
+    def state(self) -> dict:
+        bench = self.bench
+        cases = [case.view() for case in bench.cases.values()]
+        counts = {k: sum(1 for c in cases if c["state"] in v) for k, v in {
+            "entered_checked": ("entered_checked",), "held_for_owner": ("held_for_owner",),
+            "held_offline": ("held_offline",), "disputes_sent": ("dispute_sent",),
+            "other": ("failed", "readback_failed", "closed_by_owner")}.items()}
+        gateway_log = ROOT / "data" / "gateway.jsonl"
+        gateway = [json.loads(l) for l in gateway_log.read_text(encoding="utf-8").splitlines()[-50:]] if gateway_log.exists() else []
+        masks = [{"case": c["id"], "kinds": [m["kind"] for m in c["masks"]]} for c in cases if c["masks"]]
+        return {"run": self.run, "online": bench.network.online, "cases": cases, "counts": counts,
+                "total_cases": len(bench.data["cases"]),
+                "policy": {"hash": bench.policy.hash, "operations": {k: v["level"] for k, v in bench.policy.data["operations"].items()},
+                           "limits": bench.policy.limits, "egress": bench.policy.data["egress"]},
+                "boundary": {"gateway_log": gateway, "masks": masks, "model_calls_outside": 0 if not gateway else
+                             sum(1 for g in gateway if g.get("decision") == "allowed")}}
+
+
+class Handler(BaseHTTPRequestHandler):
+    server_version = "Relayloom"
+    sys_version = ""
+
+    def log_message(self, format, *args):
+        return
+
+    def common(self, status, kind, length):
+        self.send_response(status)
+        self.send_header("Content-Type", kind)
+        self.send_header("Content-Length", str(length))
+        self.send_header("Cache-Control", "no-store")
+        self.send_header("X-Content-Type-Options", "nosniff")
+        self.send_header("Content-Security-Policy", "default-src 'none'; script-src 'self'; style-src 'self'; "
+                         "img-src 'self'; connect-src 'self'; font-src 'self'; base-uri 'none'; frame-ancestors 'none'")
+        self.end_headers()
+
+    def json(self, status, value):
+        body = json.dumps(value, ensure_ascii=False).encode()
+        self.common(status, "application/json; charset=utf-8", len(body))
+        self.wfile.write(body)
+
+    def file(self, path: Path):
+        if not path.is_file():
+            return self.json(404, {"error": "not found"})
+        body = path.read_bytes()
+        self.common(200, mimetypes.guess_type(path.name)[0] or "application/octet-stream", len(body))
+        self.wfile.write(body)
+
+    def do_GET(self):
+        url = urlsplit(self.path)
+        app = self.server
+        if url.path == "/api/state":
+            return self.json(200, app.state())
+        if url.path == "/api/receipts":
+            case = parse_qs(url.query).get("case", [None])[0]
+            receipts = app.bench.chain.read(case)
+            ok, problems = verify(app.bench.chain.read(), app.run["public_key"])
+            return self.json(200, {"receipts": receipts, "verified": ok, "problems": problems,
+                                   "public_key": app.run["public_key"]})
+        if url.path == "/api/benchmark":
+            path = ROOT / "docs" / "benchmark-results.json"
+            return self.file(path) if path.exists() else self.json(404, {"error": "no benchmark results yet"})
+        if url.path.startswith("/media/"):
+            name = Path(url.path[7:]).name
+            for folder in (app.bench.run_dir / "media", FIXTURES / "photos", FIXTURES / "recorded" / "sam"):
+                if (folder / name).is_file():
+                    return self.file(folder / name)
+            return self.json(404, {"error": "not found"})
+        if url.path == "/strings.json":
+            return self.file(Path(__file__).with_name("strings.json"))
+        name = "index.html" if url.path in ("/", "") else Path(url.path).name
+        return self.file(WEB / name)
+
+    def do_POST(self):
+        app = self.server
+        origin = self.headers.get("Origin", "")
+        if self.headers.get("X-Relayloom") != "1" or (origin and urlsplit(origin).hostname != "127.0.0.1"):
+            return self.json(403, {"error": "same origin requests only"})
+        length = int(self.headers.get("Content-Length", 0))
+        if length > MAX_BODY:
+            return self.json(413, {"error": "too large"})
+        try:
+            body = json.loads(self.rfile.read(length) or b"{}")
+        except ValueError:
+            return self.json(400, {"error": "bad json"})
+        bench = app.bench
+        try:
+            if self.path == "/api/batch":
+                names = body.get("cases") or [c["case"] for c in bench.data["cases"]]
+                records = [c for c in bench.data["cases"] if c["case"] in names and c["case"] not in bench.cases]
+                bench.submit(records)
+                return self.json(200, {"started": [r["case"] for r in records]})
+            if self.path == "/api/decide":
+                threading.Thread(target=self.safe, args=(bench.decide, body.get("case", ""), body.get("decision", ""), "Owner"),
+                                 daemon=True).start()
+                return self.json(202, {"ok": True})
+            if self.path == "/api/network":
+                if body.get("online"):
+                    threading.Thread(target=self.safe, args=(bench.reconnect,), daemon=True).start()
+                else:
+                    bench.network.cut()
+                return self.json(200, {"online": bool(body.get("online"))})
+        except (Refused, KeyError) as error:
+            return self.json(409, {"error": str(error)})
+        return self.json(404, {"error": "not found"})
+
+    @staticmethod
+    def safe(function, *args):
+        try:
+            function(*args)
+        except Exception as error:  # Shown on the case through its receipts; the server keeps running.
+            print(f"action refused: {type(error).__name__}: {error}", flush=True)
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--port", type=int, default=8800)
+    parser.add_argument("--portal-port", type=int, default=8890)
+    parser.add_argument("--live", action="store_true", help="Glimmer and SAM 3.1 live on this machine, ERPNext ledger")
+    parser.add_argument("--reader", choices=("live", "recorded"), default="recorded")
+    parser.add_argument("--counter", choices=("live", "recorded"), default="recorded")
+    parser.add_argument("--ledger", choices=("local", "erpnext"), default="local")
+    parser.add_argument("--data", default=str(ROOT / "data" / "ap"))
+    parser.add_argument("--batch", action="store_true", help="start the five demo cases on launch")
+    parser.add_argument("--phone", action="store_true", help="alerts on a phone on your local network (read only, token link)")
+    parser.add_argument("--phone-port", type=int, default=8801)
+    args = parser.parse_args()
+    if args.live:
+        args.reader, args.counter, args.ledger = "live", "live", "erpnext"
+    load_env()
+    bench, run = build(args)
+    server = App(("127.0.0.1", args.port), bench, run)
+    if args.phone:
+        from .alerts import AlertHub, PhoneInbox, PhoneServer, announce
+        hub = AlertHub()
+        bench.notify = lambda kind, title, body, case, key="", params=None: hub.publish(kind, title, body, case, key, params)
+        inbox = PhoneInbox(Path(args.data) / "phone", hub, bench.counter if args.counter == "live" else None)
+        phone = PhoneServer(("0.0.0.0", args.phone_port), hub, photo_handler=inbox)
+        phone.start()
+        announce(phone)
+    print(f"Relayloom accounts payable, {run['mode']} mode: http://127.0.0.1:{args.port}")
+    print(f"Reader: {run['reader']}. Counter: {run['counter']}. Ledger: {run['ledger']}. Demo data.")
+    if args.batch:
+        bench.submit(bench.data["cases"])
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        pass
+    finally:
+        server.server_close()
+        bench.portal_server.shutdown()
+
+
+if __name__ == "__main__":
+    main()