pywrit 0.1.0__tar.gz → 0.1.2__tar.gz

{pywrit-0.1.0/pywrit.egg-info → pywrit-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pywrit
-Version: 0.1.0
+Version: 0.1.2
 Summary: Ask Writ before an agent writes — allow/deny gate with a tamper-evident audit log
 Project-URL: Homepage, https://withwrit.com
 Project-URL: Documentation, https://docs.withwrit.com
@@ -14,18 +14,45 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Dynamic: license-file
 
-# writ-cli (PyPI packaging)
+# pywrit 🏴‍☠️
 
-Installable distribution of the Writ CLI. `pip install writ-cli` gives you the
+*Arrr!* The Writ CLI — ask before yer agent writes.
+
+```bash
+pip install pywrit
+writ key --email you@company.com
+```
+
+Writ is an allow/deny gate that sits in front of every write your AI agent makes. Each check writes a tamper-evident receipt to your audit log. No more wondering who called what, or when.
+
+Shiver me timbers, it's that simple.
+
+## What it does
+
+- `writ key` — Get a free API key (1,000 receipts/month, no card)
+- `writ check` — Ask the gate before a write (ALLOW or DENY)
+- `writ revoke` — Kill switch: revoke a principal's tokens in one click
+- `writ receipts` — See your audit log
+- `writ scan` — Find every write in your repo and instrument it
+
+## Docs
+
+Full docs at [docs.withwrit.com](https://docs.withwrit.com). Quickstart at [docs.withwrit.com/quickstart](https://docs.withwrit.com/quickstart).
+
+---
+
+## Packaging notes (for maintainers)
+
+Installable distribution of the Writ CLI. `pip install pywrit` gives you the
 `writ` command — no `curl` + `chmod` dance.
 
-## Layout
+### Layout
 
 - `pyproject.toml` — package metadata, `writ` console-script entry point
 - `writ_cli/__init__.py` — version
 - `writ_cli/cli.py` — the CLI itself (stdlib-only: argparse, json, urllib)
 
-## Relationship to `gate/web/writ`
+### Relationship to `gate/web/writ`
 
 `gate/web/writ` is the **self-contained single-file script** served by the Lambda
 at `/writ` (the `curl -fsSL ... -o writ` download path). It must stay a single
@@ -35,7 +62,7 @@ file with no install step.
 byte-identical by copy. If you change CLI behavior, update **both** and keep
 them in sync — the download path and the pip path must behave the same.
 
-## Build & test locally
+### Build & test locally
 
 ```bash
 cd cli
@@ -44,20 +71,10 @@ pip install -e .                   # editable install, creates the `writ` comman
 writ --help
 ```
 
-## Publish (needs Chad's approval + PyPI credentials)
+### Publish
 
 ```bash
 cd cli
 python -m build
 twine upload dist/*
 ```
-
-## Open decisions (before first publish)
-
-1. **Distribution name**: `writ` is taken on PyPI. `pyproject.toml` uses
-   `writ-cli` as a placeholder — Chad picks the final name.
-2. **License**: the repo has no LICENSE file yet. Pick one (MIT recommended)
-   and add `license = { text = "MIT" }` + trove classifier before publishing.
-3. **Docs**: once published, update `fern/pages/quickstart.mdx` and
-   `fern/pages/cli.mdx` to offer `pip install <name>` alongside the curl path
-   (per the repo docs rule — every change ships with its docs).

pywrit-0.1.2/README.md

@@ -0,0 +1,64 @@
+# pywrit 🏴‍☠️
+
+*Arrr!* The Writ CLI — ask before yer agent writes.
+
+```bash
+pip install pywrit
+writ key --email you@company.com
+```
+
+Writ is an allow/deny gate that sits in front of every write your AI agent makes. Each check writes a tamper-evident receipt to your audit log. No more wondering who called what, or when.
+
+Shiver me timbers, it's that simple.
+
+## What it does
+
+- `writ key` — Get a free API key (1,000 receipts/month, no card)
+- `writ check` — Ask the gate before a write (ALLOW or DENY)
+- `writ revoke` — Kill switch: revoke a principal's tokens in one click
+- `writ receipts` — See your audit log
+- `writ scan` — Find every write in your repo and instrument it
+
+## Docs
+
+Full docs at [docs.withwrit.com](https://docs.withwrit.com). Quickstart at [docs.withwrit.com/quickstart](https://docs.withwrit.com/quickstart).
+
+---
+
+## Packaging notes (for maintainers)
+
+Installable distribution of the Writ CLI. `pip install pywrit` gives you the
+`writ` command — no `curl` + `chmod` dance.
+
+### Layout
+
+- `pyproject.toml` — package metadata, `writ` console-script entry point
+- `writ_cli/__init__.py` — version
+- `writ_cli/cli.py` — the CLI itself (stdlib-only: argparse, json, urllib)
+
+### Relationship to `gate/web/writ`
+
+`gate/web/writ` is the **self-contained single-file script** served by the Lambda
+at `/writ` (the `curl -fsSL ... -o writ` download path). It must stay a single
+file with no install step.
+
+`writ_cli/cli.py` is the **PyPI package source**. The two files are currently
+byte-identical by copy. If you change CLI behavior, update **both** and keep
+them in sync — the download path and the pip path must behave the same.
+
+### Build & test locally
+
+```bash
+cd cli
+python -m build                    # needs `pip install build`
+pip install -e .                   # editable install, creates the `writ` command
+writ --help
+```
+
+### Publish
+
+```bash
+cd cli
+python -m build
+twine upload dist/*
+```

{pywrit-0.1.0 → pywrit-0.1.2}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 # Distribution name: pywrit (approved by Chad 2026-09-27).
 # The bare name "writ" is taken on PyPI.
 name = "pywrit"
-version = "0.1.0"
+version = "0.1.2"
 description = "Ask Writ before an agent writes — allow/deny gate with a tamper-evident audit log"
 readme = "README.md"
 requires-python = ">=3.9"

{pywrit-0.1.0 → pywrit-0.1.2/pywrit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pywrit
-Version: 0.1.0
+Version: 0.1.2
 Summary: Ask Writ before an agent writes — allow/deny gate with a tamper-evident audit log
 Project-URL: Homepage, https://withwrit.com
 Project-URL: Documentation, https://docs.withwrit.com
@@ -14,18 +14,45 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Dynamic: license-file
 
-# writ-cli (PyPI packaging)
+# pywrit 🏴‍☠️
 
-Installable distribution of the Writ CLI. `pip install writ-cli` gives you the
+*Arrr!* The Writ CLI — ask before yer agent writes.
+
+```bash
+pip install pywrit
+writ key --email you@company.com
+```
+
+Writ is an allow/deny gate that sits in front of every write your AI agent makes. Each check writes a tamper-evident receipt to your audit log. No more wondering who called what, or when.
+
+Shiver me timbers, it's that simple.
+
+## What it does
+
+- `writ key` — Get a free API key (1,000 receipts/month, no card)
+- `writ check` — Ask the gate before a write (ALLOW or DENY)
+- `writ revoke` — Kill switch: revoke a principal's tokens in one click
+- `writ receipts` — See your audit log
+- `writ scan` — Find every write in your repo and instrument it
+
+## Docs
+
+Full docs at [docs.withwrit.com](https://docs.withwrit.com). Quickstart at [docs.withwrit.com/quickstart](https://docs.withwrit.com/quickstart).
+
+---
+
+## Packaging notes (for maintainers)
+
+Installable distribution of the Writ CLI. `pip install pywrit` gives you the
 `writ` command — no `curl` + `chmod` dance.
 
-## Layout
+### Layout
 
 - `pyproject.toml` — package metadata, `writ` console-script entry point
 - `writ_cli/__init__.py` — version
 - `writ_cli/cli.py` — the CLI itself (stdlib-only: argparse, json, urllib)
 
-## Relationship to `gate/web/writ`
+### Relationship to `gate/web/writ`
 
 `gate/web/writ` is the **self-contained single-file script** served by the Lambda
 at `/writ` (the `curl -fsSL ... -o writ` download path). It must stay a single
@@ -35,7 +62,7 @@ file with no install step.
 byte-identical by copy. If you change CLI behavior, update **both** and keep
 them in sync — the download path and the pip path must behave the same.
 
-## Build & test locally
+### Build & test locally
 
 ```bash
 cd cli
@@ -44,20 +71,10 @@ pip install -e .                   # editable install, creates the `writ` comman
 writ --help
 ```
 
-## Publish (needs Chad's approval + PyPI credentials)
+### Publish
 
 ```bash
 cd cli
 python -m build
 twine upload dist/*
 ```
-
-## Open decisions (before first publish)
-
-1. **Distribution name**: `writ` is taken on PyPI. `pyproject.toml` uses
-   `writ-cli` as a placeholder — Chad picks the final name.
-2. **License**: the repo has no LICENSE file yet. Pick one (MIT recommended)
-   and add `license = { text = "MIT" }` + trove classifier before publishing.
-3. **Docs**: once published, update `fern/pages/quickstart.mdx` and
-   `fern/pages/cli.mdx` to offer `pip install <name>` alongside the curl path
-   (per the repo docs rule — every change ships with its docs).

pywrit-0.1.2/writ_cli/cli.py

@@ -0,0 +1,730 @@
+#!/usr/bin/env python3
+"""Writ CLI. Get a key and ask the gate before a write."""
+
+import argparse
+import json
+import os
+import sys
+import urllib.error
+import urllib.request
+
+BASE = os.environ.get(
+    "WRIT_BASE",
+    "https://j72ckh66ukck2kcbq3oiwxaalm0olxwb.lambda-url.us-east-1.on.aws",
+)
+
+
+def request(method, path, payload=None, key=None, token=None):
+    headers = {"content-type": "application/json"}
+    if key:
+        headers["authorization"] = "Bearer " + key
+    elif token:
+        headers["authorization"] = token
+    data = None if payload is None else json.dumps(payload).encode()
+    req = urllib.request.Request(BASE + path, data=data, headers=headers, method=method)
+    try:
+        with urllib.request.urlopen(req, timeout=20) as resp:
+            body = resp.read().decode()
+            print(body)
+            return 0
+    except urllib.error.HTTPError as exc:
+        print(exc.read().decode(), file=sys.stderr)
+        return exc.code
+
+
+def stream_cmd(args):
+    """Tail the tenant audit log via the SSE stream, reconnecting on each
+    long-poll expiry. Prints one line per receipt."""
+    import time
+    import urllib.parse
+
+    key = args.key
+    since = args.since
+    deadline = None if args.timeout == 0 else time.time() + args.timeout
+    try:
+        while deadline is None or time.time() < deadline:
+            params = {"apiKey": key, "timeout": "10", "replay": "20"}
+            if since:
+                params["since"] = since
+            url = BASE + "/v1/receipts/stream?" + urllib.parse.urlencode(params)
+            req = urllib.request.Request(url, method="GET")
+            try:
+                with urllib.request.urlopen(req, timeout=30) as resp:
+                    data_lines = []
+                    for raw in resp:
+                        line = raw.decode("utf-8", "replace").rstrip("\n")
+                        if line.startswith("data:"):
+                            data_lines.append(line[5:].strip())
+                        elif line == "" and data_lines:
+                            try:
+                                r = json.loads("".join(data_lines))
+                            except json.JSONDecodeError:
+                                data_lines = []
+                                continue
+                            ts = time.strftime("%H:%M:%S", time.localtime(r.get("createdAt", 0)))
+                            print(f"{ts} {r.get('decision','?'):7} {r.get('verb','')} {r.get('target','')} "
+                                  f"sponsor={r.get('sponsorId','')} agent={r.get('agentId','')} "
+                                  f"id={r.get('receiptId','')}", flush=True)
+                            since = r.get("receiptId", since)
+                            data_lines = []
+                        # ": ping" heartbeats and "id:"/"event:" lines are ignored
+            except urllib.error.HTTPError as exc:
+                print(exc.read().decode(), file=sys.stderr)
+                return exc.code
+            except (urllib.error.URLError, TimeoutError, ConnectionError) as exc:
+                print(f"stream reconnecting: {exc}", file=sys.stderr)
+                time.sleep(2)
+    except KeyboardInterrupt:
+        pass
+    return 0
+
+
+# ---------------------------------------------------------------------------
+# writ scan: find writes in a repo, map them to verbs, and generate the
+# instrumentation diff + policy file + coverage report. Stdlib only.
+# ---------------------------------------------------------------------------
+import ast as _ast
+import difflib as _difflib
+import pathlib as _pathlib
+
+_SCAN_MARKER = "writ instrumentation (generated by `writ scan`)"
+_SCAN_HELPER = '''# --- writ instrumentation (generated by `writ scan`) ---
+import json as _writ_json
+import os as _writ_os
+import urllib.request as _writ_urllib
+
+
+_WRIT_BASE = _writ_os.environ.get(
+    "WRIT_BASE",
+    "https://j72ckh66ukck2kcbq3oiwxaalm0olxwb.lambda-url.us-east-1.on.aws",
+)
+_WRIT_KEY = _writ_os.environ.get("WRIT_API_KEY", "")
+_WRIT_SPONSOR = _writ_os.environ.get("WRIT_SPONSOR", "app")
+_WRIT_AGENT = _writ_os.environ.get("WRIT_AGENT", "app")
+
+
+def _writ_check(verb, target="", purpose=""):
+    """Ask the Writ gate before a write. Fails closed (DENY) on any error."""
+    try:
+        body = _writ_json.dumps(
+            {
+                "sponsorId": _WRIT_SPONSOR,
+                "agentId": _WRIT_AGENT,
+                "verb": verb,
+                "target": target,
+                "purpose": purpose,
+            }
+        ).encode()
+        req = _writ_urllib.Request(
+            _WRIT_BASE + "/v1/check",
+            data=body,
+            headers={
+                "content-type": "application/json",
+                "authorization": "Bearer " + _WRIT_KEY,
+            },
+        )
+        with _writ_urllib.urlopen(req, timeout=10) as resp:
+            return _writ_json.loads(resp.read().decode()).get("decision", "DENY")
+    except Exception:
+        return "DENY"
+
+
+# --- end writ instrumentation ---
+'''
+
+_DB_BARE = {"execute", "executemany", "executescript", "flush", "merge",
+            "bulk_save_objects"}
+_DB_HINTED = {"save", "update", "delete", "add", "remove", "commit", "insert"}
+_DB_HINTS = {"db", "session", "conn", "connection", "cursor", "engine",
+             "store", "collection", "table", "model", "query", "tx",
+             "transaction", "repository", "repo", "dal"}
+_HTTP_BARE = {"post", "put", "patch"}
+_HTTP_HINTED = {"delete", "request"}
+_HTTP_HINTS = {"requests", "session", "client", "http", "api", "rest"}
+_PATH_METHODS = {"write_text", "write_bytes", "unlink", "mkdir", "rmdir",
+                 "rename", "replace", "touch", "symlink_to", "hardlink_to"}
+_OS_WRITES = {"remove", "unlink", "rename", "replace", "mkdir", "makedirs",
+              "rmdir", "removedirs", "truncate", "symlink", "link"}
+_SHUTIL_WRITES = {"rmtree", "move", "copy", "copy2", "copytree", "chown"}
+_EMAIL_METHODS = {"sendmail", "send_message", "send_email",
+                  "send_templated_email"}
+_QUEUE_BARE = {"publish", "produce", "enqueue"}
+_QUEUE_HINTED = {"send"}
+_QUEUE_HINTS = {"queue", "topic", "channel", "bus", "stream", "kafka",
+                "redis", "sqs", "pubsub", "mq", "exchange"}
+_AWS_METHODS = {"put_object", "put_item", "delete_item", "delete_object",
+                "send_message", "publish", "upload_file", "upload_fileobj",
+                "send_email", "start_execution", "put_metric_data"}
+
+_ACTION_SYNONYMS = {
+    "create": "create", "add": "create", "insert": "create",
+    "register": "create", "enroll": "create", "subscribe": "create",
+    "update": "update", "edit": "update", "modify": "update",
+    "patch": "update", "set": "update", "upsert": "update",
+    "rename": "update",
+    "delete": "delete", "remove": "delete", "destroy": "delete",
+    "drop": "delete", "archive": "delete", "purge": "delete",
+    "send": "send", "dispatch": "send", "notify": "send", "emit": "send",
+    "broadcast": "send", "alert": "send",
+    "publish": "publish",
+    "charge": "charge", "refund": "refund", "capture": "capture",
+    "void": "void", "payout": "payout",
+    "issue": "issue", "revoke": "revoke", "grant": "grant",
+    "upload": "upload", "save": "save", "write": "write",
+    "store": "write",
+    "revoked": "revoke", "created": "create", "deleted": "delete",
+    "updated": "update", "granted": "grant", "archived": "delete",
+}
+_GENERIC_PREFIXES = {"issue", "process", "handle", "do", "run", "perform",
+                     "execute", "make", "get", "fetch",
+                     "is", "has", "are", "was", "were", "check"}
+_KIND_FALLBACK_ACTION = {"db": "write", "http": "call", "file": "write",
+                         "email": "send", "queue": "publish", "aws": "write"}
+_SKIP_DIRS = {"src", "app", "lib", "api", "v1", "v2", "server", "services",
+              "models", "routes", "handlers", "controllers", "actions",
+              "core", "common", "utils", "util", "pkg", "internal"}
+_SKIP_FILES = {"__init__", "__main__", "main", "app", "index", "conftest",
+               "setup"}
+_SKIP_DIR_NAMES = {".git", ".hg", ".svn", "__pycache__", ".venv", "venv",
+                   "node_modules", ".tox", ".eggs", "dist", "build"}
+
+
+class _WriteSite:
+    __slots__ = ("file", "func", "cls", "lineno", "kind", "snippet")
+
+    def __init__(self, file, func, cls, lineno, kind, snippet):
+        self.file = file
+        self.func = func
+        self.cls = cls
+        self.lineno = lineno
+        self.kind = kind
+        self.snippet = snippet
+
+
+def _recv_name(func):
+    if isinstance(func, _ast.Attribute):
+        v = func.value
+        if isinstance(v, _ast.Name):
+            return v.id.lower()
+        if isinstance(v, _ast.Attribute):
+            return v.attr.lower()
+        if isinstance(v, _ast.Call):
+            return _recv_name(v.func)
+    return ""
+
+
+def _root_name(func):
+    while isinstance(func, _ast.Attribute):
+        func = func.value
+    return func.id.lower() if isinstance(func, _ast.Name) else ""
+
+
+_READ_SQL = ("select", "with", "explain", "describe", "show", "pragma")
+
+
+def _sql_is_write(node):
+    """True unless the statement is clearly a read (SELECT/WITH/...)."""
+    if not node.args:
+        return True
+    first = node.args[0]
+    if isinstance(first, _ast.Constant) and isinstance(first.value, str):
+        stmt = first.value.lstrip(" (").lower()
+        return not stmt.startswith(_READ_SQL)
+    return True
+
+
+def _open_is_write(node):
+    mode = None
+    if len(node.args) >= 2 and isinstance(node.args[1], _ast.Constant):
+        mode = node.args[1].value
+    for kw in node.keywords:
+        if kw.arg == "mode" and isinstance(kw.value, _ast.Constant):
+            mode = kw.value.value
+    return isinstance(mode, str) and any(c in mode for c in "wax+")
+
+
+def _classify_call(node):
+    func = node.func
+    if isinstance(func, _ast.Name) and func.id == "open":
+        return "file" if _open_is_write(node) else None
+    if not isinstance(func, _ast.Attribute):
+        return None
+    name = func.attr
+    recv = _recv_name(func)
+    root = _root_name(func)
+    if root == "os" and name in _OS_WRITES:
+        return "file"
+    if root == "shutil" and name in _SHUTIL_WRITES:
+        return "file"
+    if name in _PATH_METHODS:
+        return "file"
+    if name in _EMAIL_METHODS:
+        return "email"
+    if name in _AWS_METHODS:
+        return "aws"
+    if name in _DB_BARE:
+        if name in ("execute", "executemany", "executescript") \
+                and not _sql_is_write(node):
+            return None
+        return "db"
+    if name in _DB_HINTED:
+        return "db" if recv in _DB_HINTS else None
+    if name in _HTTP_BARE:
+        return "http"
+    if name in _HTTP_HINTED and recv in _HTTP_HINTS:
+        return "http"
+    if name in _QUEUE_BARE:
+        return "queue"
+    if name in _QUEUE_HINTED and recv in _QUEUE_HINTS:
+        return "queue"
+    return None
+
+
+def _is_gate_call(node):
+    func = node.func
+    if isinstance(func, _ast.Name):
+        return func.id in ("writ_check", "_writ_check")
+    if isinstance(func, _ast.Attribute):
+        return func.attr in ("writ_check", "_writ_check")
+    return False
+
+
+class _ScanVisitor(_ast.NodeVisitor):
+    def __init__(self, src, filename):
+        self.src = src
+        self.filename = filename
+        self.func_stack = []
+        self.cls_stack = []
+        self.sites = []
+        self.gated = set()  # (func_name, func_lineno)
+
+    def visit_ClassDef(self, node):
+        self.cls_stack.append(node.name)
+        self.generic_visit(node)
+        self.cls_stack.pop()
+
+    def visit_FunctionDef(self, node):
+        self._visit_func(node)
+
+    def visit_AsyncFunctionDef(self, node):
+        self._visit_func(node)
+
+    def _visit_func(self, node):
+        self.func_stack.append(node)
+        self.generic_visit(node)
+        self.func_stack.pop()
+
+    def visit_Call(self, node):
+        if self.func_stack:
+            func = self.func_stack[-1]
+            if _is_gate_call(node):
+                self.gated.add((func.name, func.lineno))
+            kind = _classify_call(node)
+            if kind:
+                cls = self.cls_stack[-1] if self.cls_stack else ""
+                try:
+                    seg = _ast.get_source_segment(self.src, node) or ""
+                except Exception:
+                    seg = ""
+                snippet = " ".join(seg.split())[:100]
+                self.sites.append(_WriteSite(self.filename, func.name, cls,
+                                             node.lineno, kind, snippet))
+        self.generic_visit(node)
+
+
+def _infer_action(func_name, kind):
+    tokens = [t for t in func_name.lower().split("_") if t]
+    if not tokens:
+        return _KIND_FALLBACK_ACTION[kind]
+    first = tokens[0]
+    if first in _GENERIC_PREFIXES:
+        if len(tokens) > 1:
+            second = tokens[1]
+            return _ACTION_SYNONYMS.get(second, second)
+        return _KIND_FALLBACK_ACTION[kind]
+    return _ACTION_SYNONYMS.get(first, first)
+
+
+def _infer_domain(rel_path, cls_name):
+    parts = [p for p in rel_path.parts[:-1]
+             if p not in _SKIP_DIRS and not p.startswith((".", "_"))]
+    if parts:
+        return parts[0].lower().replace("-", "_")
+    stem = rel_path.stem
+    if stem not in _SKIP_FILES:
+        return stem.lower().replace("-", "_")
+    if cls_name:
+        d = cls_name.lower().replace("service", "").replace("handler", "")
+        return d or "app"
+    return "app"
+
+
+def infer_verb(rel_path, func_name, cls_name, kind):
+    return "%s.%s" % (_infer_domain(rel_path, cls_name),
+                      _infer_action(func_name, kind))
+
+
+def _should_skip(path, root, excludes):
+    rel = path.relative_to(root)
+    if any(p in _SKIP_DIR_NAMES or p.startswith(".") for p in rel.parts[:-1]):
+        return True
+    if path.name.startswith("test_") or path.name.endswith("_test.py"):
+        return True
+    if "tests" in rel.parts or "testing" in rel.parts:
+        return True
+    s = str(path)
+    return any(e in s for e in excludes)
+
+
+def _collect_files(root, excludes):
+    return sorted(p for p in root.rglob("*.py")
+                  if p.is_file() and not _should_skip(p, root, excludes))
+
+
+def _find_func(tree, func_name, site_lineno):
+    for node in _ast.walk(tree):
+        if isinstance(node, (_ast.FunctionDef, _ast.AsyncFunctionDef)) \
+                and node.name == func_name \
+                and node.lineno <= site_lineno <= (node.end_lineno or 10**9):
+            return node
+    return None
+
+
+def _helper_insert_index(lines, tree):
+    last_import_end = -1
+    for node in tree.body:
+        if isinstance(node, (_ast.Import, _ast.ImportFrom)):
+            last_import_end = node.end_lineno - 1
+    if last_import_end >= 0:
+        return last_import_end
+    if tree.body and isinstance(tree.body[0], _ast.Expr) and \
+            isinstance(tree.body[0].value, _ast.Constant) and \
+            isinstance(tree.body[0].value.value, str):
+        return tree.body[0].end_lineno - 1
+    idx = -1
+    if lines and lines[0].startswith("#!"):
+        idx = 0
+    return idx
+
+
+def _build_edits(path, rel_path, source, sites, gated):
+    """Return (edits, verbs, n_gates, manual)."""
+    tree = _ast.parse(source)
+    lines = source.splitlines(keepends=True)
+    by_func = {}
+    for s in sites:
+        by_func.setdefault((s.func, s.cls), []).append(s)
+    edits, verbs, manual = [], {}, []
+    n_gates = 0
+    for (func_name, cls_name), ss in sorted(by_func.items()):
+        verb = infer_verb(rel_path, func_name, cls_name, ss[0].kind)
+        verbs[verb] = "require_grant"
+        node = _find_func(tree, func_name, min(s.lineno for s in ss))
+        if node is None:
+            continue
+        if (func_name, node.lineno) in gated:
+            continue
+        if not node.body or node.body[0].lineno == node.lineno:
+            manual.append((func_name, verb, "one-line function; gate by hand"))
+            continue
+        first = lines[node.body[0].lineno - 1]
+        stripped = first.lstrip()
+        indent = first[:len(first) - len(stripped)]
+        if not indent:
+            dline = lines[node.lineno - 1]
+            indent = dline[:len(dline) - len(dline.lstrip())] + "    "
+        gate = ["%sif _writ_check(\"%s\") != \"ALLOW\":\n" % (indent, verb),
+                "%s    raise PermissionError(\"writ denied %s\")\n" % (indent, verb)]
+        edits.append((node.lineno - 1, gate))
+        n_gates += 1
+    if edits and _SCAN_MARKER not in source:
+        idx = _helper_insert_index(lines, tree)
+        helper_lines = ["\n"] + _SCAN_HELPER.splitlines(keepends=True)
+        if not helper_lines[-1].endswith("\n"):
+            helper_lines[-1] += "\n"
+        # avoid doubling blank lines
+        edits.append((idx, helper_lines))
+    return edits, verbs, n_gates, manual
+
+
+def _apply_edits(lines, edits):
+    out = list(lines)
+    for idx, new_lines in sorted(edits, key=lambda e: e[0], reverse=True):
+        out[idx + 1:idx + 1] = new_lines
+    return out
+
+
+def scan_cmd(args):
+    import json as _json
+    root = _pathlib.Path(args.path).resolve()
+    if not root.is_dir():
+        print("error: not a directory: %s" % args.path, file=sys.stderr)
+        return 2
+    files = _collect_files(root, args.exclude or [])
+
+    sites, gated, skipped = [], set(), []
+    for path in files:
+        try:
+            src = path.read_text(encoding="utf-8")
+        except (UnicodeDecodeError, OSError):
+            skipped.append(str(path))
+            continue
+        try:
+            tree = _ast.parse(src)
+        except SyntaxError:
+            skipped.append(str(path))
+            continue
+        v = _ScanVisitor(src, str(path))
+        v.visit(tree)
+        sites.extend(v.sites)
+        gated.update((str(path), n, ln) for (n, ln) in v.gated)
+
+    by_func = {}
+    for s in sites:
+        by_func.setdefault((s.file, s.func, s.cls), []).append(s)
+    gated_funcs = {(f, n) for (f, n, ln) in gated}
+    # a site is gated if its function has a gate call; match by file+name
+    gated_site_count = sum(1 for s in sites if (s.file, s.func) in gated_funcs)
+    total = len(sites)
+    pct = (100 * gated_site_count // total) if total else 100
+
+    verbs = {}
+    for (f, func_name, cls_name), ss in sorted(by_func.items()):
+        rel = _pathlib.Path(f).relative_to(root)
+        verbs.setdefault(infer_verb(rel, func_name, cls_name, ss[0].kind),
+                         "require_grant")
+
+    print("writ scan: %s" % root)
+    print("  files scanned: %d  skipped: %d" % (len(files), len(skipped)))
+    print("  write sites: %d in %d function(s)" % (total, len(by_func)))
+    print("  gated: %d/%d (%d%%)" % (gated_site_count, total, pct))
+    if verbs:
+        print("  verbs discovered: %d" % len(verbs))
+        for vname in sorted(verbs):
+            print("    %s" % vname)
+
+    if verbs:
+        ppath = _pathlib.Path(args.policy_out)
+        ppath.write_text(_json.dumps(verbs, indent=2) + "\n")
+        print("  policy written: %s" % ppath)
+
+    results = []  # (path, old_lines, new_lines, n_gates)
+    manuals = []
+    for path in sorted({s.file for s in sites}):
+        src = _pathlib.Path(path).read_text(encoding="utf-8")
+        rel = _pathlib.Path(path).relative_to(root)
+        gated_here = {(n, ln) for (f, n, ln) in gated if f == path}
+        edits, _, n_gates, manual = _build_edits(
+            path, rel, src, [s for s in sites if s.file == path], gated_here)
+        manuals.extend((path, m[0], m[1], m[2]) for m in manual)
+        if not edits:
+            continue
+        new_lines = _apply_edits(src.splitlines(keepends=True), edits)
+        results.append((path, src.splitlines(keepends=True), new_lines,
+                        n_gates))
+        diff = "".join(_difflib.unified_diff(
+            src.splitlines(keepends=True), new_lines,
+            fromfile="a/" + str(rel), tofile="b/" + str(rel)))
+        print(diff, end="")
+    for path, func_name, verb, why in manuals:
+        print("  manual: %s %s() [%s]: %s" % (path, func_name, verb, why))
+
+    if not results:
+        print("nothing to instrument.")
+        return 0
+
+    total_gates = sum(r[3] for r in results)
+    do_apply = args.apply
+    if do_apply and not args.yes:
+        try:
+            ans = input("apply %d gate(s) to %d file(s)? [y/N] "
+                        % (total_gates, len(results))).strip().lower()
+        except EOFError:
+            ans = ""
+        do_apply = ans in ("y", "yes")
+    if do_apply:
+        for path, _old, new, _n in results:
+            _pathlib.Path(path).write_text("".join(new), encoding="utf-8")
+        print("applied %d gate(s) to %d file(s)." % (total_gates, len(results)))
+    else:
+        print("re-run with --apply to write these changes.")
+
+    if args.push_policy:
+        if not args.key:
+            print("error: --push-policy needs --key", file=sys.stderr)
+            return 2
+        return request("PUT", "/v1/policy", verbs, key=args.key)
+    return 0
+
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Ask Writ before an agent writes.")
+    sub = parser.add_subparsers(dest="cmd", required=True)
+
+    key = sub.add_parser("key", help="Get a free API key + tenant")
+    key.add_argument("--email", required=True)
+    key.add_argument("--tenant-name", default="", help="Optional tenant name (defaults to email domain)")
+    key.add_argument("--invite-code", default="", help="Join an existing tenant instead of creating one")
+
+    me = sub.add_parser("me", help="Show tenant, key meta, and policy")
+    me.add_argument("--key", required=True)
+
+    MODES = ("allow", "deny", "require_grant", "step_up")
+    policy = sub.add_parser("policy", help="Get or set tenant verb policy")
+    policy.add_argument("--key", required=True)
+    policy.add_argument("--set", nargs=2, metavar=("VERB", "MODE"), action="append", default=[])
+
+    check = sub.add_parser("check", help="ALLOW or DENY a write")
+    check.add_argument("--key", required=True)
+    check.add_argument("--sponsor", required=True)
+    check.add_argument("--agent", required=True)
+    check.add_argument("--verb", required=True)
+    check.add_argument("--target", required=True)
+    check.add_argument("--purpose", required=True)
+
+    sandbox = sub.add_parser("sandbox", help="90-second grant for demo_write")
+    sandbox.add_argument("--sponsor", required=True)
+    sandbox.add_argument("--agent", required=True)
+    sandbox.add_argument("--target", required=True)
+    sandbox.add_argument("--purpose", required=True)
+
+    revoke = sub.add_parser("revoke", help="Kill switch: revoke a principal (sponsor token)")
+    revoke.add_argument("--sponsor", required=True)
+    revoke.add_argument("--agent", required=True)
+    revoke.add_argument("--reason", default="")
+    revoke.add_argument("--sponsor-token", default=os.environ.get("WRIT_SPONSOR_TOKEN", ""))
+
+    reinstate = sub.add_parser("reinstate", help="Undo a revocation (sponsor token)")
+    reinstate.add_argument("--sponsor", required=True)
+    reinstate.add_argument("--agent", required=True)
+    reinstate.add_argument("--sponsor-token", default=os.environ.get("WRIT_SPONSOR_TOKEN", ""))
+
+    revoked = sub.add_parser("revoked", help="List revoked principals (sponsor token)")
+    revoked.add_argument("--sponsor-token", default=os.environ.get("WRIT_SPONSOR_TOKEN", ""))
+
+    receipts = sub.add_parser("receipts", help="Latest receipts for your tenant")
+    receipts.add_argument("--key", required=True)
+
+    stream = sub.add_parser("stream", help="Tail the live audit log (SSE stream)")
+    stream.add_argument("--key", required=True)
+    stream.add_argument("--since", default="", help="receiptId to resume after")
+    stream.add_argument("--timeout", type=int, default=600, help="Seconds to stream before exiting (0 = forever)")
+
+    verify = sub.add_parser("verify-chain", help="Verify the tenant audit-log hash chain")
+    verify.add_argument("--key", required=True)
+    verify.add_argument("--limit", type=int, default=200, help="Max receipts to verify (1-1000)")
+
+    invite = sub.add_parser("invite", help="Create a team invite code for your tenant")
+    invite.add_argument("--key", required=True)
+
+    grant = sub.add_parser("grant", help="Sponsor approval: grant one write (sponsor token)")
+    grant.add_argument("--sponsor", required=True)
+    grant.add_argument("--agent", required=True)
+    grant.add_argument("--verb", required=True)
+    grant.add_argument("--target", required=True)
+    grant.add_argument("--purpose", required=True)
+    grant.add_argument("--ttl", type=int, default=90, help="Seconds the grant stays valid (1-3600)")
+    grant.add_argument("--sponsor-token", default=os.environ.get("WRIT_SPONSOR_TOKEN", ""))
+
+    tv = sub.add_parser("token-verify", help="Validate an ALLOW auth token")
+    tv.add_argument("--key", required=True)
+    tv.add_argument("--token", required=True)
+    tv.add_argument("--verb", default=None)
+    tv.add_argument("--target", default=None)
+    tv.add_argument("--purpose", default=None)
+
+    scan = sub.add_parser("scan", help="Scan a repo for writes; map to verbs; diff instrumentation")
+    scan.add_argument("path", nargs="?", default=".", help="Repo root to scan (default: .)")
+    scan.add_argument("--exclude", action="append", default=[], metavar="SUBSTR",
+                      help="Skip paths containing SUBSTR (repeatable)")
+    scan.add_argument("--policy-out", default="writ-policy.json",
+                      help="Where to write the discovered verb policy")
+    scan.add_argument("--apply", action="store_true",
+                      help="Write instrumentation into the repo")
+    scan.add_argument("--yes", action="store_true",
+                      help="Apply without prompting")
+    scan.add_argument("--push-policy", action="store_true",
+                      help="PUT the discovered policy to the gate (needs --key)")
+    scan.add_argument("--key", default="",
+                      help="API key (for --push-policy)")
+
+    args = parser.parse_args()
+    if args.cmd == "key":
+        payload = {"email": args.email}
+        if args.tenant_name.strip():
+            payload["tenantName"] = args.tenant_name.strip()
+        if args.invite_code.strip():
+            payload["inviteCode"] = args.invite_code.strip()
+        return request("POST", "/v1/keys", payload)
+    if args.cmd == "invite":
+        return request("POST", "/v1/tenant/invites", key=args.key)
+    if args.cmd == "grant":
+        if not args.sponsor_token:
+            print("error: sponsor token required (--sponsor-token or WRIT_SPONSOR_TOKEN)", file=sys.stderr)
+            return 2
+        return request(
+            "POST",
+            "/v1/grants",
+            {
+                "sponsorId": args.sponsor,
+                "agentId": args.agent,
+                "verb": args.verb,
+                "target": args.target,
+                "purpose": args.purpose,
+                "ttlSeconds": args.ttl,
+            },
+            token="Bearer " + args.sponsor_token,
+        )
+    if args.cmd == "me":
+        return request("GET", "/v1/me", key=args.key)
+    if args.cmd == "policy":
+        if args.set:
+            for verb, mode in args.set:
+                if mode not in MODES:
+                    print(f"error: mode must be one of {', '.join(MODES)}", file=sys.stderr)
+                    return 2
+            return request("PUT", "/v1/policy", {verb: mode for verb, mode in args.set}, key=args.key)
+        return request("GET", "/v1/policy", key=args.key)
+    if args.cmd == "receipts":
+        return request("GET", "/v1/receipts", key=args.key)
+    if args.cmd == "stream":
+        return stream_cmd(args)
+    if args.cmd == "verify-chain":
+        return request("GET", f"/v1/receipts/verify?limit={args.limit}", key=args.key)
+    if args.cmd == "token-verify":
+        payload = {"token": args.token}
+        for field in ("verb", "target", "purpose"):
+            value = getattr(args, field)
+            if value is not None:
+                payload[field] = value
+        return request("POST", "/v1/tokens/verify", payload, key=args.key)
+    if args.cmd == "scan":
+        return scan_cmd(args)
+    if args.cmd in ("revoke", "reinstate", "revoked"):
+        if not args.sponsor_token:
+            print("error: sponsor token required (--sponsor-token or WRIT_SPONSOR_TOKEN)", file=sys.stderr)
+            return 2
+        token = "Bearer " + args.sponsor_token
+        if args.cmd == "revoked":
+            return request("GET", "/v1/revoked", token=token)
+        payload = {"sponsorId": args.sponsor, "agentId": args.agent}
+        if args.cmd == "revoke":
+            if args.reason:
+                payload["reason"] = args.reason
+            return request("POST", "/v1/revoke", payload, token=token)
+        return request("POST", "/v1/reinstate", payload, token=token)
+    body = {
+        "sponsorId": args.sponsor,
+        "agentId": args.agent,
+        "verb": args.verb if args.cmd == "check" else "demo_write",
+        "target": args.target,
+        "purpose": args.purpose,
+    }
+    if args.cmd == "sandbox":
+        return request("POST", "/v1/sandbox", body)
+    return request("POST", "/v1/check", body, key=args.key)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

pywrit-0.1.0/README.md

@@ -1,47 +0,0 @@
-# writ-cli (PyPI packaging)
-
-Installable distribution of the Writ CLI. `pip install writ-cli` gives you the
-`writ` command — no `curl` + `chmod` dance.
-
-## Layout
-
-- `pyproject.toml` — package metadata, `writ` console-script entry point
-- `writ_cli/__init__.py` — version
-- `writ_cli/cli.py` — the CLI itself (stdlib-only: argparse, json, urllib)
-
-## Relationship to `gate/web/writ`
-
-`gate/web/writ` is the **self-contained single-file script** served by the Lambda
-at `/writ` (the `curl -fsSL ... -o writ` download path). It must stay a single
-file with no install step.
-
-`writ_cli/cli.py` is the **PyPI package source**. The two files are currently
-byte-identical by copy. If you change CLI behavior, update **both** and keep
-them in sync — the download path and the pip path must behave the same.
-
-## Build & test locally
-
-```bash
-cd cli
-python -m build                    # needs `pip install build`
-pip install -e .                   # editable install, creates the `writ` command
-writ --help
-```
-
-## Publish (needs Chad's approval + PyPI credentials)
-
-```bash
-cd cli
-python -m build
-twine upload dist/*
-```
-
-## Open decisions (before first publish)
-
-1. **Distribution name**: `writ` is taken on PyPI. `pyproject.toml` uses
-   `writ-cli` as a placeholder — Chad picks the final name.
-2. **License**: the repo has no LICENSE file yet. Pick one (MIT recommended)
-   and add `license = { text = "MIT" }` + trove classifier before publishing.
-3. **Docs**: once published, update `fern/pages/quickstart.mdx` and
-   `fern/pages/cli.mdx` to offer `pip install <name>` alongside the curl path
-   (per the repo docs rule — every change ships with its docs).

pywrit-0.1.0/writ_cli/cli.py

@@ -1,234 +0,0 @@
-#!/usr/bin/env python3
-"""Writ CLI. Get a key and ask the gate before a write."""
-
-import argparse
-import json
-import os
-import sys
-import urllib.error
-import urllib.request
-
-BASE = os.environ.get(
-    "WRIT_BASE",
-    "https://j72ckh66ukck2kcbq3oiwxaalm0olxwb.lambda-url.us-east-1.on.aws",
-)
-
-
-def request(method, path, payload=None, key=None, token=None):
-    headers = {"content-type": "application/json"}
-    if key:
-        headers["authorization"] = "Bearer " + key
-    elif token:
-        headers["authorization"] = token
-    data = None if payload is None else json.dumps(payload).encode()
-    req = urllib.request.Request(BASE + path, data=data, headers=headers, method=method)
-    try:
-        with urllib.request.urlopen(req, timeout=20) as resp:
-            body = resp.read().decode()
-            print(body)
-            return 0
-    except urllib.error.HTTPError as exc:
-        print(exc.read().decode(), file=sys.stderr)
-        return exc.code
-
-
-def stream_cmd(args):
-    """Tail the tenant audit log via the SSE stream, reconnecting on each
-    long-poll expiry. Prints one line per receipt."""
-    import time
-    import urllib.parse
-
-    key = args.key
-    since = args.since
-    deadline = None if args.timeout == 0 else time.time() + args.timeout
-    try:
-        while deadline is None or time.time() < deadline:
-            params = {"apiKey": key, "timeout": "10", "replay": "20"}
-            if since:
-                params["since"] = since
-            url = BASE + "/v1/receipts/stream?" + urllib.parse.urlencode(params)
-            req = urllib.request.Request(url, method="GET")
-            try:
-                with urllib.request.urlopen(req, timeout=30) as resp:
-                    data_lines = []
-                    for raw in resp:
-                        line = raw.decode("utf-8", "replace").rstrip("\n")
-                        if line.startswith("data:"):
-                            data_lines.append(line[5:].strip())
-                        elif line == "" and data_lines:
-                            try:
-                                r = json.loads("".join(data_lines))
-                            except json.JSONDecodeError:
-                                data_lines = []
-                                continue
-                            ts = time.strftime("%H:%M:%S", time.localtime(r.get("createdAt", 0)))
-                            print(f"{ts} {r.get('decision','?'):7} {r.get('verb','')} {r.get('target','')} "
-                                  f"sponsor={r.get('sponsorId','')} agent={r.get('agentId','')} "
-                                  f"id={r.get('receiptId','')}", flush=True)
-                            since = r.get("receiptId", since)
-                            data_lines = []
-                        # ": ping" heartbeats and "id:"/"event:" lines are ignored
-            except urllib.error.HTTPError as exc:
-                print(exc.read().decode(), file=sys.stderr)
-                return exc.code
-            except (urllib.error.URLError, TimeoutError, ConnectionError) as exc:
-                print(f"stream reconnecting: {exc}", file=sys.stderr)
-                time.sleep(2)
-    except KeyboardInterrupt:
-        pass
-    return 0
-
-
-def main():
-    parser = argparse.ArgumentParser(description="Ask Writ before an agent writes.")
-    sub = parser.add_subparsers(dest="cmd", required=True)
-
-    key = sub.add_parser("key", help="Get a free API key + tenant")
-    key.add_argument("--email", required=True)
-    key.add_argument("--tenant-name", default="", help="Optional tenant name (defaults to email domain)")
-    key.add_argument("--invite-code", default="", help="Join an existing tenant instead of creating one")
-
-    me = sub.add_parser("me", help="Show tenant, key meta, and policy")
-    me.add_argument("--key", required=True)
-
-    MODES = ("allow", "deny", "require_grant", "step_up")
-    policy = sub.add_parser("policy", help="Get or set tenant verb policy")
-    policy.add_argument("--key", required=True)
-    policy.add_argument("--set", nargs=2, metavar=("VERB", "MODE"), action="append", default=[])
-
-    check = sub.add_parser("check", help="ALLOW or DENY a write")
-    check.add_argument("--key", required=True)
-    check.add_argument("--sponsor", required=True)
-    check.add_argument("--agent", required=True)
-    check.add_argument("--verb", required=True)
-    check.add_argument("--target", required=True)
-    check.add_argument("--purpose", required=True)
-
-    sandbox = sub.add_parser("sandbox", help="90-second grant for demo_write")
-    sandbox.add_argument("--sponsor", required=True)
-    sandbox.add_argument("--agent", required=True)
-    sandbox.add_argument("--target", required=True)
-    sandbox.add_argument("--purpose", required=True)
-
-    revoke = sub.add_parser("revoke", help="Kill switch: revoke a principal (sponsor token)")
-    revoke.add_argument("--sponsor", required=True)
-    revoke.add_argument("--agent", required=True)
-    revoke.add_argument("--reason", default="")
-    revoke.add_argument("--sponsor-token", default=os.environ.get("WRIT_SPONSOR_TOKEN", ""))
-
-    reinstate = sub.add_parser("reinstate", help="Undo a revocation (sponsor token)")
-    reinstate.add_argument("--sponsor", required=True)
-    reinstate.add_argument("--agent", required=True)
-    reinstate.add_argument("--sponsor-token", default=os.environ.get("WRIT_SPONSOR_TOKEN", ""))
-
-    revoked = sub.add_parser("revoked", help="List revoked principals (sponsor token)")
-    revoked.add_argument("--sponsor-token", default=os.environ.get("WRIT_SPONSOR_TOKEN", ""))
-
-    receipts = sub.add_parser("receipts", help="Latest receipts for your tenant")
-    receipts.add_argument("--key", required=True)
-
-    stream = sub.add_parser("stream", help="Tail the live audit log (SSE stream)")
-    stream.add_argument("--key", required=True)
-    stream.add_argument("--since", default="", help="receiptId to resume after")
-    stream.add_argument("--timeout", type=int, default=600, help="Seconds to stream before exiting (0 = forever)")
-
-    verify = sub.add_parser("verify-chain", help="Verify the tenant audit-log hash chain")
-    verify.add_argument("--key", required=True)
-    verify.add_argument("--limit", type=int, default=200, help="Max receipts to verify (1-1000)")
-
-    invite = sub.add_parser("invite", help="Create a team invite code for your tenant")
-    invite.add_argument("--key", required=True)
-
-    grant = sub.add_parser("grant", help="Sponsor approval: grant one write (sponsor token)")
-    grant.add_argument("--sponsor", required=True)
-    grant.add_argument("--agent", required=True)
-    grant.add_argument("--verb", required=True)
-    grant.add_argument("--target", required=True)
-    grant.add_argument("--purpose", required=True)
-    grant.add_argument("--ttl", type=int, default=90, help="Seconds the grant stays valid (1-3600)")
-    grant.add_argument("--sponsor-token", default=os.environ.get("WRIT_SPONSOR_TOKEN", ""))
-
-    tv = sub.add_parser("token-verify", help="Validate an ALLOW auth token")
-    tv.add_argument("--key", required=True)
-    tv.add_argument("--token", required=True)
-    tv.add_argument("--verb", default=None)
-    tv.add_argument("--target", default=None)
-    tv.add_argument("--purpose", default=None)
-
-    args = parser.parse_args()
-    if args.cmd == "key":
-        payload = {"email": args.email}
-        if args.tenant_name.strip():
-            payload["tenantName"] = args.tenant_name.strip()
-        if args.invite_code.strip():
-            payload["inviteCode"] = args.invite_code.strip()
-        return request("POST", "/v1/keys", payload)
-    if args.cmd == "invite":
-        return request("POST", "/v1/tenant/invites", key=args.key)
-    if args.cmd == "grant":
-        if not args.sponsor_token:
-            print("error: sponsor token required (--sponsor-token or WRIT_SPONSOR_TOKEN)", file=sys.stderr)
-            return 2
-        return request(
-            "POST",
-            "/v1/grants",
-            {
-                "sponsorId": args.sponsor,
-                "agentId": args.agent,
-                "verb": args.verb,
-                "target": args.target,
-                "purpose": args.purpose,
-                "ttlSeconds": args.ttl,
-            },
-            token="Bearer " + args.sponsor_token,
-        )
-    if args.cmd == "me":
-        return request("GET", "/v1/me", key=args.key)
-    if args.cmd == "policy":
-        if args.set:
-            for verb, mode in args.set:
-                if mode not in MODES:
-                    print(f"error: mode must be one of {', '.join(MODES)}", file=sys.stderr)
-                    return 2
-            return request("PUT", "/v1/policy", {verb: mode for verb, mode in args.set}, key=args.key)
-        return request("GET", "/v1/policy", key=args.key)
-    if args.cmd == "receipts":
-        return request("GET", "/v1/receipts", key=args.key)
-    if args.cmd == "stream":
-        return stream_cmd(args)
-    if args.cmd == "verify-chain":
-        return request("GET", f"/v1/receipts/verify?limit={args.limit}", key=args.key)
-    if args.cmd == "token-verify":
-        payload = {"token": args.token}
-        for field in ("verb", "target", "purpose"):
-            value = getattr(args, field)
-            if value is not None:
-                payload[field] = value
-        return request("POST", "/v1/tokens/verify", payload, key=args.key)
-    if args.cmd in ("revoke", "reinstate", "revoked"):
-        if not args.sponsor_token:
-            print("error: sponsor token required (--sponsor-token or WRIT_SPONSOR_TOKEN)", file=sys.stderr)
-            return 2
-        token = "Bearer " + args.sponsor_token
-        if args.cmd == "revoked":
-            return request("GET", "/v1/revoked", token=token)
-        payload = {"sponsorId": args.sponsor, "agentId": args.agent}
-        if args.cmd == "revoke":
-            if args.reason:
-                payload["reason"] = args.reason
-            return request("POST", "/v1/revoke", payload, token=token)
-        return request("POST", "/v1/reinstate", payload, token=token)
-    body = {
-        "sponsorId": args.sponsor,
-        "agentId": args.agent,
-        "verb": args.verb if args.cmd == "check" else "demo_write",
-        "target": args.target,
-        "purpose": args.purpose,
-    }
-    if args.cmd == "sandbox":
-        return request("POST", "/v1/sandbox", body)
-    return request("POST", "/v1/check", body, key=args.key)
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())