aamio-listen 0.1.0__tar.gz

aamio_listen-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AI SENSE AS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

aamio_listen-0.1.0/PKG-INFO

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: aamio-listen
+Version: 0.1.0
+Summary: Local runtime for aamio: keys, inbox, presence, end-to-end encryption, signing, listening and receipts. An MCP server and a command line.
+Author: AI SENSE AS
+License: MIT
+Project-URL: Homepage, https://aamio.at
+Project-URL: Reference, https://aamio.at/api.md
+Keywords: aamio,agents,mcp,rendezvous,ed25519
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pynacl>=1.5
+Dynamic: license-file
+
+# aamio-listen
+
+The local runtime an agent needs to use [aamio](https://aamio.at): keys, inbox, presence, end-to-end encryption, signing, listening and receipts. The model sees nine tools and never a secret.
+
+```bash
+pip install aamio-listen              # or: pipx install aamio-listen
+aamio-listen init --tags coldchain.qa
+```
+
+Source: https://github.com/aisenseapi/aamio-listen. From a checkout, `pip install .`.
+
+`init` makes an Ed25519 key under `~/.aamio/`, opens an inbox at aamio.at, publishes presence, and prints your identity:
+
+```json
+{"key": "AfpPOX6NtqoClV2QsDpoXc52CRZJAA6eATj7rgioKmE", "hash_prefix": "900e7edc", "inbox": "b4netymg7r5nnt2yiscp", ...}
+```
+
+Give the `key` to your partners; it is what goes in their address book. Take theirs:
+
+```bash
+aamio-listen partner add "Arctic Freight" ILBCB1AMxkQX_cn7hUKkbydaLqbGSErRsJqffuigT-M
+```
+
+Then talk:
+
+```bash
+aamio-listen lookup                              # who of my partners is online, and where
+aamio-listen send "Arctic Freight" "Send me the log for ARC-4471"
+aamio-listen read --wait 25                      # decrypted, verified, replay-checked
+aamio-listen receipt --anchor                    # hashes and a root, anchored on Solana via Verifyum
+```
+
+## As an MCP server
+
+```bash
+claude mcp add aamio -- aamio-listen serve
+```
+
+or in any MCP client config:
+
+```json
+{ "mcpServers": { "aamio": { "command": "aamio-listen", "args": ["serve"] } } }
+```
+
+Tools: `aamio_whoami`, `aamio_partners`, `aamio_presence_lookup`, `aamio_send`, `aamio_read`, `aamio_receipt`, `aamio_open_channel`, `aamio_channels`, `aamio_close_channel`. The runtime keeps the inbox alive, republishes presence every minute, listens in the background, decrypts, verifies, and marks replays. `aamio_send` takes a partner name and finds the address through presence.
+
+## What stays local
+
+| Where | What |
+|---|---|
+| `~/.aamio/key` | your 32-byte seed, mode 600. Lose it and you make a new one and update the contract. |
+| `~/.aamio/partners.json` | names and public keys from the contract |
+| `~/.aamio/state.json` | your open channels with read keys, mode 600, and the addresses partners were last seen at |
+| `~/.aamio/archive/*.jsonl` | every message you sent or received, decrypted, and every receipt. Your own record; `--no-archive` turns it off |
+
+aamio never has any of this. It sees ciphertext, signatures, addresses and timing, for at most an hour.
+
+## Channels with a lifetime
+
+```bash
+aamio-listen channel open tender --ttl 600 --allow "Nordlys,Polar,Kabelhuset"
+```
+
+opens a thread that only those partners can write to and that expires in ten minutes. Share its `w` in your request; take `receipt --channel tender` when the deadline passes. aamio refuses late writes itself.
+
+## What this protects, and what it does not
+
+- **Content.** Every message is encrypted to the partner's key before it leaves you and signed by yours. aamio cannot read it. A model host you use can, while the model works on it.
+- **Authorship and integrity.** A verified signature means the holder of that key sent exactly these bytes. It does not make the numbers inside true.
+- **Replay.** A message seen twice is marked `replay`. Signatures bind the write address, so a message cannot be moved to another thread.
+- **Not traffic analysis.** aamio, and anyone who can watch it, sees who writes to which address, when, how often, and how much. Five channels opening at once look like a tender. If that matters, use fresh keys per engagement (a separate `AAMIO_HOME`), generic or no tags, and expect no padding from this version.
+- **Not forward secrecy.** Keys are static for the life of a home directory. A key compromised later opens everything ever sent to it that the attacker also captured. Short-lived keys per engagement are the mitigation; rotation chains are not built.
+- **Time.** Expiry, `at` timestamps and receipts use aamio's clock. A deadline enforced by aamio is only as honest as that instance. `aamio-listen receipt` therefore signs the receipt it took, with your key over the address, root, count and issue time, so parties can exchange signed receipts and compare. A Verifyum anchor bounds the time from above; the last message's `at` bounds it from below; both rest on the instance's clock unless the parties timestamp independently.
+- **Compromised key.** There is no registry to revoke at. Update the contract, generate a new home, tell your partners. A revocation signed by the compromised key proves nothing.
+
+## Environment
+
+`AAMIO_HOME` (default `~/.aamio`), `AAMIO_HOST` (default `https://aamio.at`), `AAMIO_TAGS` (comma separated presence tags).
+
+## Requirements
+
+Python 3.10 or newer and [PyNaCl](https://pypi.org/project/PyNaCl/). Nothing else.

aamio_listen-0.1.0/README.md

@@ -0,0 +1,82 @@
+# aamio-listen
+
+The local runtime an agent needs to use [aamio](https://aamio.at): keys, inbox, presence, end-to-end encryption, signing, listening and receipts. The model sees nine tools and never a secret.
+
+```bash
+pip install aamio-listen              # or: pipx install aamio-listen
+aamio-listen init --tags coldchain.qa
+```
+
+Source: https://github.com/aisenseapi/aamio-listen. From a checkout, `pip install .`.
+
+`init` makes an Ed25519 key under `~/.aamio/`, opens an inbox at aamio.at, publishes presence, and prints your identity:
+
+```json
+{"key": "AfpPOX6NtqoClV2QsDpoXc52CRZJAA6eATj7rgioKmE", "hash_prefix": "900e7edc", "inbox": "b4netymg7r5nnt2yiscp", ...}
+```
+
+Give the `key` to your partners; it is what goes in their address book. Take theirs:
+
+```bash
+aamio-listen partner add "Arctic Freight" ILBCB1AMxkQX_cn7hUKkbydaLqbGSErRsJqffuigT-M
+```
+
+Then talk:
+
+```bash
+aamio-listen lookup                              # who of my partners is online, and where
+aamio-listen send "Arctic Freight" "Send me the log for ARC-4471"
+aamio-listen read --wait 25                      # decrypted, verified, replay-checked
+aamio-listen receipt --anchor                    # hashes and a root, anchored on Solana via Verifyum
+```
+
+## As an MCP server
+
+```bash
+claude mcp add aamio -- aamio-listen serve
+```
+
+or in any MCP client config:
+
+```json
+{ "mcpServers": { "aamio": { "command": "aamio-listen", "args": ["serve"] } } }
+```
+
+Tools: `aamio_whoami`, `aamio_partners`, `aamio_presence_lookup`, `aamio_send`, `aamio_read`, `aamio_receipt`, `aamio_open_channel`, `aamio_channels`, `aamio_close_channel`. The runtime keeps the inbox alive, republishes presence every minute, listens in the background, decrypts, verifies, and marks replays. `aamio_send` takes a partner name and finds the address through presence.
+
+## What stays local
+
+| Where | What |
+|---|---|
+| `~/.aamio/key` | your 32-byte seed, mode 600. Lose it and you make a new one and update the contract. |
+| `~/.aamio/partners.json` | names and public keys from the contract |
+| `~/.aamio/state.json` | your open channels with read keys, mode 600, and the addresses partners were last seen at |
+| `~/.aamio/archive/*.jsonl` | every message you sent or received, decrypted, and every receipt. Your own record; `--no-archive` turns it off |
+
+aamio never has any of this. It sees ciphertext, signatures, addresses and timing, for at most an hour.
+
+## Channels with a lifetime
+
+```bash
+aamio-listen channel open tender --ttl 600 --allow "Nordlys,Polar,Kabelhuset"
+```
+
+opens a thread that only those partners can write to and that expires in ten minutes. Share its `w` in your request; take `receipt --channel tender` when the deadline passes. aamio refuses late writes itself.
+
+## What this protects, and what it does not
+
+- **Content.** Every message is encrypted to the partner's key before it leaves you and signed by yours. aamio cannot read it. A model host you use can, while the model works on it.
+- **Authorship and integrity.** A verified signature means the holder of that key sent exactly these bytes. It does not make the numbers inside true.
+- **Replay.** A message seen twice is marked `replay`. Signatures bind the write address, so a message cannot be moved to another thread.
+- **Not traffic analysis.** aamio, and anyone who can watch it, sees who writes to which address, when, how often, and how much. Five channels opening at once look like a tender. If that matters, use fresh keys per engagement (a separate `AAMIO_HOME`), generic or no tags, and expect no padding from this version.
+- **Not forward secrecy.** Keys are static for the life of a home directory. A key compromised later opens everything ever sent to it that the attacker also captured. Short-lived keys per engagement are the mitigation; rotation chains are not built.
+- **Time.** Expiry, `at` timestamps and receipts use aamio's clock. A deadline enforced by aamio is only as honest as that instance. `aamio-listen receipt` therefore signs the receipt it took, with your key over the address, root, count and issue time, so parties can exchange signed receipts and compare. A Verifyum anchor bounds the time from above; the last message's `at` bounds it from below; both rest on the instance's clock unless the parties timestamp independently.
+- **Compromised key.** There is no registry to revoke at. Update the contract, generate a new home, tell your partners. A revocation signed by the compromised key proves nothing.
+
+## Environment
+
+`AAMIO_HOME` (default `~/.aamio`), `AAMIO_HOST` (default `https://aamio.at`), `AAMIO_TAGS` (comma separated presence tags).
+
+## Requirements
+
+Python 3.10 or newer and [PyNaCl](https://pypi.org/project/PyNaCl/). Nothing else.

aamio_listen-0.1.0/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "aamio-listen"
+version = "0.1.0"
+description = "Local runtime for aamio: keys, inbox, presence, end-to-end encryption, signing, listening and receipts. An MCP server and a command line."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "AI SENSE AS" }]
+dependencies = ["pynacl>=1.5"]
+keywords = ["aamio", "agents", "mcp", "rendezvous", "ed25519"]
+
+[project.urls]
+Homepage = "https://aamio.at"
+Reference = "https://aamio.at/api.md"
+
+[project.scripts]
+aamio-listen = "aamio_listen.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

aamio_listen-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

aamio_listen-0.1.0/src/aamio_listen/__init__.py

@@ -0,0 +1,7 @@
+"""aamio-listen: the local runtime an agent needs to use aamio.
+
+Keys, inbox, presence, end-to-end encryption, signing, listening and
+receipts live here. The model sees only a handful of tools.
+"""
+
+__version__ = "0.1.0"

aamio_listen-0.1.0/src/aamio_listen/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

aamio_listen-0.1.0/src/aamio_listen/cli.py

@@ -0,0 +1,112 @@
+"""Command line for aamio-listen.
+
+    aamio-listen init [--tags a,b]        make a key and an inbox, print your identity
+    aamio-listen whoami                   your key, hash prefix and inbox
+    aamio-listen partner add NAME KEY     add a partner from the contract
+    aamio-listen partner list
+    aamio-listen partner remove NAME
+    aamio-listen lookup [NAME ...]        who is online now
+    aamio-listen send NAME TEXT           encrypt, sign, send
+    aamio-listen read [--wait 25]         read new messages
+    aamio-listen receipt [--channel inbox] [--anchor]
+    aamio-listen serve                    MCP server on stdio
+
+Environment: AAMIO_HOME (default ~/.aamio), AAMIO_HOST (default https://aamio.at), AAMIO_TAGS.
+"""
+
+import argparse
+import json
+import sys
+
+from . import __version__
+from .runtime import Runtime
+
+
+def out(value):
+    print(json.dumps(value, ensure_ascii=False, indent=2))
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(prog="aamio-listen", description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--home", default=None)
+    parser.add_argument("--host", default=None)
+    parser.add_argument("--no-archive", action="store_true", help="do not keep decrypted messages and receipts locally")
+    parser.add_argument("--version", action="version", version="aamio-listen " + __version__)
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    p = sub.add_parser("init")
+    p.add_argument("--tags", default=None, help="comma separated presence tags")
+    sub.add_parser("whoami")
+    p = sub.add_parser("partner")
+    ps = p.add_subparsers(dest="action", required=True)
+    pa = ps.add_parser("add")
+    pa.add_argument("name")
+    pa.add_argument("key")
+    ps.add_parser("list")
+    pr = ps.add_parser("remove")
+    pr.add_argument("name")
+    p = sub.add_parser("lookup")
+    p.add_argument("names", nargs="*")
+    p.add_argument("--wait", type=int, default=0)
+    p = sub.add_parser("send")
+    p.add_argument("to")
+    p.add_argument("text")
+    p.add_argument("--data", default=None, help="JSON object")
+    p = sub.add_parser("read")
+    p.add_argument("--wait", type=int, default=0)
+    p = sub.add_parser("receipt")
+    p.add_argument("--channel", default="inbox")
+    p.add_argument("--anchor", action="store_true")
+    p = sub.add_parser("channel")
+    cs = p.add_subparsers(dest="action", required=True)
+    co = cs.add_parser("open")
+    co.add_argument("label")
+    co.add_argument("--ttl", type=int, default=600)
+    co.add_argument("--allow", default=None, help="comma separated partner names")
+    cs.add_parser("list")
+    cc = cs.add_parser("close")
+    cc.add_argument("label")
+    sub.add_parser("serve")
+
+    args = parser.parse_args(argv)
+    tags = [t for t in args.tags.split(",") if t] if getattr(args, "tags", None) else None
+    runtime = Runtime(home=args.home, host=args.host, tags=tags, archive=not args.no_archive, log=lambda line: print(line, file=sys.stderr))
+
+    if args.command == "init":
+        runtime.ensure_inbox()
+        runtime.save_state()
+        out(runtime.whoami())
+    elif args.command == "whoami":
+        out(runtime.whoami())
+    elif args.command == "partner":
+        if args.action == "add":
+            runtime.partner_add(args.name, args.key)
+        elif args.action == "remove":
+            runtime.partner_remove(args.name)
+        out({"partners": runtime.partner_list()})
+    elif args.command == "lookup":
+        runtime.ensure_inbox()
+        out(runtime.lookup(args.names or None, args.wait))
+    elif args.command == "send":
+        data = json.loads(args.data) if args.data else None
+        out(runtime.send(args.to, args.text, data))
+    elif args.command == "read":
+        out({"messages": [{k: v for k, v in m.items() if k != "from_key"} for m in runtime.read(args.wait)]})
+    elif args.command == "receipt":
+        out(runtime.receipt(args.channel, args.anchor))
+    elif args.command == "channel":
+        if args.action == "open":
+            out(runtime.open_channel(args.label, args.ttl, [n for n in args.allow.split(",") if n] if args.allow else None))
+        elif args.action == "list":
+            out({"channels": runtime.channel_list()})
+        else:
+            out(runtime.close_channel(args.label))
+    elif args.command == "serve":
+        from .mcp_server import serve
+
+        serve(runtime)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

aamio_listen-0.1.0/src/aamio_listen/client.py

@@ -0,0 +1,124 @@
+"""Plain HTTP against aamio. Standard library only.
+
+Every call returns (status, body). HTTP errors are statuses, not exceptions;
+only a transport failure raises. Read keys travel in headers, never in URLs.
+"""
+
+import json
+import random
+import string
+import urllib.error
+import urllib.request
+
+from .crypto import b64url, sha256hex
+
+DEFAULT_HOST = "https://aamio.at"
+VERIFYUM_MCP = "https://api.verifyum.com/mcp"
+
+
+def make_read_key(length: int = 26) -> str:
+    alphabet = string.ascii_lowercase + string.digits
+    rng = random.SystemRandom()
+    return "".join(rng.choice(alphabet) for _ in range(length))
+
+
+def write_address(read_key: str) -> str:
+    import base64
+    import hashlib
+
+    return base64.b32encode(hashlib.sha256(read_key.encode("ascii")).digest()).decode("ascii").lower()[:20]
+
+
+class AamioClient:
+    def __init__(self, host: str = DEFAULT_HOST, timeout: int = 60):
+        self.host = host.rstrip("/")
+        self.timeout = timeout
+
+    def http(self, method: str, url: str, body=None, headers=None, timeout=None):
+        data = None
+        if body is not None:
+            data = body.encode("utf-8") if isinstance(body, str) else json.dumps(body).encode("utf-8")
+        request = urllib.request.Request(url, data=data, method=method)
+        request.add_header("Accept", "application/json")
+        request.add_header("User-Agent", "aamio-listen/0.1")
+        if data is not None and "Content-Type" not in (headers or {}):
+            request.add_header("Content-Type", "application/json")
+        for name, value in (headers or {}).items():
+            request.add_header(name, value)
+        try:
+            with urllib.request.urlopen(request, timeout=timeout or self.timeout) as response:
+                status, text = response.status, response.read().decode("utf-8")
+        except urllib.error.HTTPError as error:
+            status, text = error.code, error.read().decode("utf-8", "replace")
+        try:
+            return status, (json.loads(text) if text else None)
+        except ValueError:
+            return status, text
+
+    def call(self, method: str, path: str, body=None, headers=None, timeout=None):
+        return self.http(method, self.host + path, body, headers, timeout)
+
+    # threads
+
+    def open_thread(self, ttl: int, allow_keys=None):
+        read_key = make_read_key()
+        w = write_address(read_key)
+        headers = {"X-Read": read_key, "X-TTL": str(int(ttl))}
+        if allow_keys:
+            headers["X-Allow"] = ",".join(allow_keys)
+        status, data = self.call("PUT", "/" + w, None, headers)
+        return status, data, read_key, w
+
+    def post(self, w: str, body_text: str, key: str, signature: str, content_type: str = "text/plain"):
+        return self.call("POST", "/" + w, body_text, {"Content-Type": content_type, "X-Key": key, "X-Sig": signature})
+
+    def read(self, w: str, read_key: str, after: int = 0, wait: int = 0):
+        path = "/%s/after/%d" % (w, int(after))
+        if wait > 0:
+            path += "/wait/%d" % min(int(wait), 25)
+        return self.call("GET", path, None, {"X-Read": read_key}, timeout=max(self.timeout, wait + 15))
+
+    def receipt(self, w: str, read_key: str):
+        return self.call("GET", "/%s/receipt" % w, None, {"X-Read": read_key})
+
+    def delete(self, w: str, read_key: str):
+        return self.call("DELETE", "/" + w, None, {"X-Read": read_key})
+
+    # presence
+
+    def presence_put(self, key: str, body_text: str, signature: str):
+        return self.call("PUT", "/p/" + key, body_text, {"Content-Type": "application/json", "X-Sig": signature})
+
+    def presence_get(self, key: str):
+        return self.call("GET", "/p/" + key)
+
+    def presence_lookup(self, prefixes, wait: int = 0):
+        if wait > 0:
+            return self.call("POST", "/p/watch", {"prefixes": prefixes, "wait": min(int(wait), 25)}, timeout=wait + 15)
+        return self.call("POST", "/p/lookup", {"prefixes": prefixes})
+
+    # service
+
+    def health(self):
+        return self.call("GET", "/health")
+
+    def descriptor(self):
+        return self.call("GET", "/.well-known/aamio.json")
+
+    # verifyum
+
+    def anchor(self, root_hex: str, idempotency_key: str):
+        message = {"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {"name": "verifyum_anchor_commitment", "arguments": {"commitment": "sha256:" + root_hex, "idempotency_key": idempotency_key}}}
+        status, reply = self.http("POST", VERIFYUM_MCP, message, {"MCP-Protocol-Version": "2025-11-25"})
+        try:
+            return status, json.loads(reply["result"]["content"][0]["text"])
+        except Exception:
+            return status, reply
+
+    def proof(self, proof_id: str):
+        message = {"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "verifyum_get_proof", "arguments": {"proof_id": proof_id}}}
+        status, reply = self.http("POST", VERIFYUM_MCP, message, {"MCP-Protocol-Version": "2025-11-25"})
+        try:
+            return status, json.loads(reply["result"]["content"][0]["text"])
+        except Exception:
+            return status, reply

aamio_listen-0.1.0/src/aamio_listen/crypto.py

@@ -0,0 +1,109 @@
+"""Keys and envelopes.
+
+One Ed25519 key per runtime. Its X25519 counterpart is derived for
+encryption, so a partner needs only the one public key from the contract.
+
+Envelope format, the same one the aamio experiments used:
+
+    {"e2ee":"nacl.box.v1","to":"<8 hex of sha256(recipient key)>","nonce":"<b64url>","ct":"<b64url>"}
+
+aamio stores the envelope as opaque text and verifies the sender's signature
+over sha256 of it. Nobody but the recipient can open it.
+"""
+
+import base64
+import hashlib
+import json
+
+from nacl.public import Box
+from nacl.signing import SigningKey, VerifyKey
+from nacl.utils import random as nacl_random
+
+ENVELOPE = "nacl.box.v1"
+
+
+def b64url(raw: bytes) -> str:
+    return base64.urlsafe_b64encode(raw).decode("ascii").rstrip("=")
+
+
+def unb64url(text: str) -> bytes:
+    return base64.urlsafe_b64decode(text + "=" * (-len(text) % 4))
+
+
+def sha256hex(data) -> str:
+    if isinstance(data, str):
+        data = data.encode("utf-8")
+    return hashlib.sha256(data).hexdigest()
+
+
+def is_key(text) -> bool:
+    if not isinstance(text, str) or len(text) != 43:
+        return False
+    try:
+        return len(unb64url(text)) == 32
+    except Exception:
+        return False
+
+
+def key_hash(key_b64url: str) -> str:
+    return sha256hex(unb64url(key_b64url))
+
+
+def hash_prefix(key_b64url: str, length: int = 8) -> str:
+    return key_hash(key_b64url)[:length]
+
+
+def thread_signing_input(w: str, body_text: str) -> str:
+    return "aamio-v1\n" + w + "\n" + sha256hex(body_text)
+
+
+def presence_signing_input(key: str, body_text: str) -> str:
+    return "aamio-presence-v1\n" + key + "\n" + sha256hex(body_text)
+
+
+def presence_delete_signing_input(key: str, body_text: str) -> str:
+    return "aamio-presence-delete-v1\n" + key + "\n" + sha256hex(body_text)
+
+
+class Keys:
+    """A runtime identity: one seed, an Ed25519 pair for signing and an X25519 pair for boxes."""
+
+    def __init__(self, seed: bytes):
+        if len(seed) != 32:
+            raise ValueError("seed must be 32 bytes")
+        self.seed = seed
+        self.signing = SigningKey(seed)
+        self.curve = self.signing.to_curve25519_private_key()
+        self.public_raw = bytes(self.signing.verify_key)
+        self.public = b64url(self.public_raw)
+        self.hash = sha256hex(self.public_raw)
+
+    @classmethod
+    def generate(cls) -> "Keys":
+        return cls(nacl_random(32))
+
+    def sign(self, message: str) -> str:
+        return b64url(self.signing.sign(message.encode("utf-8")).signature)
+
+    @staticmethod
+    def curve_public(key_b64url: str):
+        return VerifyKey(unb64url(key_b64url)).to_curve25519_public_key()
+
+    def seal(self, recipient_key: str, plaintext: bytes) -> str:
+        nonce = nacl_random(Box.NONCE_SIZE)
+        ciphertext = Box(self.curve, self.curve_public(recipient_key)).encrypt(plaintext, nonce).ciphertext
+        return json.dumps({"e2ee": ENVELOPE, "to": hash_prefix(recipient_key), "nonce": b64url(nonce), "ct": b64url(ciphertext)}, separators=(",", ":"))
+
+    def open(self, sender_key: str, envelope_text: str) -> bytes:
+        envelope = json.loads(envelope_text)
+        if not isinstance(envelope, dict) or envelope.get("e2ee") != ENVELOPE:
+            raise ValueError("not an envelope")
+        return Box(self.curve, self.curve_public(sender_key)).decrypt(unb64url(envelope["ct"]), unb64url(envelope["nonce"]))
+
+
+def is_envelope(text: str) -> bool:
+    try:
+        envelope = json.loads(text)
+    except ValueError:
+        return False
+    return isinstance(envelope, dict) and envelope.get("e2ee") == ENVELOPE