mesh-peer-registry 0.1.0__tar.gz

mesh_peer_registry-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Emil Tsoi
+
+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.

mesh_peer_registry-0.1.0/PKG-INFO

@@ -0,0 +1,121 @@
+Metadata-Version: 2.4
+Name: mesh-peer-registry
+Version: 0.1.0
+Summary: Shared, language-agnostic peer registry for hermes-mesh and openclaw-mesh with Ed25519 signing.
+Author: Emil Tsoi
+License: MIT
+Project-URL: Homepage, https://github.com/emiltsoi/mesh-peer-registry
+Project-URL: Repository, https://github.com/emiltsoi/mesh-peer-registry.git
+Project-URL: Issues, https://github.com/emiltsoi/mesh-peer-registry/issues
+Keywords: mesh,peer,registry,ed25519,aiohttp,openclaw,hermes
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Communications
+Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp>=3.9
+Requires-Dist: cryptography>=41.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+Dynamic: license-file
+
+# mesh-peer-registry
+
+A small, shared, language-agnostic peer registry for the mesh network used by [`hermes-mesh`](https://github.com/emiltsoi/hermes-mesh) and [`openclaw-mesh`](https://github.com/emiltsoi/openclaw-mesh).
+
+Peers register with an Ed25519 public key and a webhook URL, then discover each other over a simple HTTP API. The server never holds private keys.
+
+## About
+
+`mesh-peer-registry` provides a centralized but state-light way for mesh agents to announce themselves to one another:
+
+- Peers register an Ed25519 **public key** and a **webhook URL** under a unique name.
+- Registration and deregistration requests are signed by the peer's private key, so the registry can trust the public key it stores.
+- Other peers query the registry to find a recipient's webhook URL and public key.
+- Mesh messages are signed by the sender and verified by the receiver against the sender's public key from the registry.
+
+The signing protocol uses compact, deterministic, sorted-key JSON, making it straightforward to implement in other runtimes (e.g. the Node.js implementation in `openclaw-mesh`).
+
+## Features
+
+- **HTTP API** for register, list, get, and deregister operations.
+- **Ed25519 signatures** on all mutating requests.
+- **In-memory** store by default, or **file-backed** persistence via `--store`.
+- **CLI** server launcher.
+- **Python client** (`RegistryClient`) with built-in signing.
+- No private keys kept by the registry.
+
+## Quick start
+
+Install and run the server:
+
+```bash
+pip install mesh-peer-registry
+mesh-peer-registry --port 8646 --store ./registry.json
+```
+
+The server will listen on `http://127.0.0.1:8646`.
+
+## API
+
+- `POST /register` — register or update a peer (signed with the peer's private key).
+- `GET /peers` — list all peers.
+- `GET /peers/{name}` — get one peer.
+- `DELETE /peers/{name}` — deregister a peer (signed with the peer's private key).
+
+All registration/deregistration requests must include a valid Ed25519 signature in the `X-Mesh-Signature` header.
+
+## Python client
+
+```python
+from mesh_peer_registry.crypto import generate_keypair
+from mesh_peer_registry.client import RegistryClient
+
+private, public = generate_keypair()
+client = RegistryClient("http://127.0.0.1:8646", private, public)
+
+client.register(
+    "agent0",
+    "http://127.0.0.1:8645/mesh/receive",
+    role="operator",
+    description="Hermes operator node",
+)
+
+print(client.list_peers())
+```
+
+## Verifying a message
+
+```python
+from mesh_peer_registry.crypto import verify_message
+from mesh_peer_registry.client import RegistryClient
+
+client = RegistryClient("http://127.0.0.1:8646", "", "")
+peer = client.get_peer("agent0")
+
+# body is the raw request body; signature is from the X-Mesh-Signature header.
+ok = verify_message(peer.public_key, body, signature)
+```
+
+## Development
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+pip install -e ".[dev]"
+pytest
+```
+
+## License
+
+[MIT](LICENSE)

mesh_peer_registry-0.1.0/README.md

@@ -0,0 +1,90 @@
+# mesh-peer-registry
+
+A small, shared, language-agnostic peer registry for the mesh network used by [`hermes-mesh`](https://github.com/emiltsoi/hermes-mesh) and [`openclaw-mesh`](https://github.com/emiltsoi/openclaw-mesh).
+
+Peers register with an Ed25519 public key and a webhook URL, then discover each other over a simple HTTP API. The server never holds private keys.
+
+## About
+
+`mesh-peer-registry` provides a centralized but state-light way for mesh agents to announce themselves to one another:
+
+- Peers register an Ed25519 **public key** and a **webhook URL** under a unique name.
+- Registration and deregistration requests are signed by the peer's private key, so the registry can trust the public key it stores.
+- Other peers query the registry to find a recipient's webhook URL and public key.
+- Mesh messages are signed by the sender and verified by the receiver against the sender's public key from the registry.
+
+The signing protocol uses compact, deterministic, sorted-key JSON, making it straightforward to implement in other runtimes (e.g. the Node.js implementation in `openclaw-mesh`).
+
+## Features
+
+- **HTTP API** for register, list, get, and deregister operations.
+- **Ed25519 signatures** on all mutating requests.
+- **In-memory** store by default, or **file-backed** persistence via `--store`.
+- **CLI** server launcher.
+- **Python client** (`RegistryClient`) with built-in signing.
+- No private keys kept by the registry.
+
+## Quick start
+
+Install and run the server:
+
+```bash
+pip install mesh-peer-registry
+mesh-peer-registry --port 8646 --store ./registry.json
+```
+
+The server will listen on `http://127.0.0.1:8646`.
+
+## API
+
+- `POST /register` — register or update a peer (signed with the peer's private key).
+- `GET /peers` — list all peers.
+- `GET /peers/{name}` — get one peer.
+- `DELETE /peers/{name}` — deregister a peer (signed with the peer's private key).
+
+All registration/deregistration requests must include a valid Ed25519 signature in the `X-Mesh-Signature` header.
+
+## Python client
+
+```python
+from mesh_peer_registry.crypto import generate_keypair
+from mesh_peer_registry.client import RegistryClient
+
+private, public = generate_keypair()
+client = RegistryClient("http://127.0.0.1:8646", private, public)
+
+client.register(
+    "agent0",
+    "http://127.0.0.1:8645/mesh/receive",
+    role="operator",
+    description="Hermes operator node",
+)
+
+print(client.list_peers())
+```
+
+## Verifying a message
+
+```python
+from mesh_peer_registry.crypto import verify_message
+from mesh_peer_registry.client import RegistryClient
+
+client = RegistryClient("http://127.0.0.1:8646", "", "")
+peer = client.get_peer("agent0")
+
+# body is the raw request body; signature is from the X-Mesh-Signature header.
+ok = verify_message(peer.public_key, body, signature)
+```
+
+## Development
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+pip install -e ".[dev]"
+pytest
+```
+
+## License
+
+[MIT](LICENSE)

mesh_peer_registry-0.1.0/mesh_peer_registry/__init__.py

@@ -0,0 +1,26 @@
+"""Shared peer registry package for hermes-mesh and openclaw-mesh."""
+from __future__ import annotations
+
+from .crypto import (
+    canonicalize_payload,
+    generate_keypair,
+    sign_json,
+    sign_message,
+    verify_json,
+    verify_message,
+)
+from .client import RegistryClient
+from .models import PeerInfo
+from .server import create_app
+
+__all__ = [
+    "canonicalize_payload",
+    "generate_keypair",
+    "sign_json",
+    "sign_message",
+    "verify_json",
+    "verify_message",
+    "RegistryClient",
+    "PeerInfo",
+    "create_app",
+]

mesh_peer_registry-0.1.0/mesh_peer_registry/cli.py

@@ -0,0 +1,26 @@
+"""CLI entry point for the mesh peer registry server."""
+from __future__ import annotations
+
+import argparse
+import os
+
+from aiohttp import web
+
+from .server import create_app
+
+__all__ = ["main"]
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Run the mesh peer registry")
+    parser.add_argument("--host", default="127.0.0.1")
+    parser.add_argument("--port", type=int, default=8646)
+    parser.add_argument(
+        "--store",
+        default="~/.mesh/registry.json",
+        help="Path to the JSON store file",
+    )
+    args = parser.parse_args()
+
+    app = create_app(os.path.expanduser(args.store))
+    web.run_app(app, host=args.host, port=args.port)

mesh_peer_registry-0.1.0/mesh_peer_registry/client.py

@@ -0,0 +1,106 @@
+"""Synchronous HTTP client for the mesh peer registry."""
+from __future__ import annotations
+
+import json
+import urllib.error
+import urllib.request
+
+from .crypto import sign_json
+from .models import PeerInfo
+
+__all__ = ["RegistryClient"]
+
+
+class RegistryClient:
+    """Synchronous client for a mesh-peer-registry server."""
+
+    def __init__(
+        self,
+        registry_url: str,
+        private_key_pem: str,
+        public_key_pem: str,
+        timeout: float = 10.0,
+    ) -> None:
+        self.registry_url = registry_url.rstrip("/")
+        self.private_key_pem = private_key_pem
+        self.public_key_pem = public_key_pem
+        self.timeout = timeout
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        payload: dict | None = None,
+        signature_payload: dict | None = None,
+    ) -> dict:
+        url = f"{self.registry_url}{path}"
+        headers: dict[str, str] = {}
+        data: bytes | None = None
+
+        if payload is not None:
+            data = json.dumps(payload, sort_keys=True).encode("utf-8")
+            headers["Content-Type"] = "application/json"
+
+        if signature_payload is not None:
+            sig = sign_json(self.private_key_pem, signature_payload)
+            headers["X-Mesh-Signature"] = sig
+
+        req = urllib.request.Request(
+            url, data=data, headers=headers, method=method
+        )
+        try:
+            with urllib.request.urlopen(req, timeout=self.timeout) as resp:
+                return json.loads(resp.read().decode("utf-8"))
+        except urllib.error.HTTPError as exc:
+            body = exc.read().decode("utf-8")
+            try:
+                detail = json.loads(body)
+            except json.JSONDecodeError:
+                detail = body
+            raise RegistryClientError(
+                status=exc.code, message=detail
+            ) from exc
+
+    def register(
+        self,
+        name: str,
+        url: str,
+        role: str = "agent",
+        description: str = "",
+    ) -> dict:
+        payload = {
+            "name": name,
+            "url": url,
+            "public_key": self.public_key_pem,
+            "role": role,
+            "description": description,
+        }
+        return self._request("POST", "/register", payload, payload)
+
+    def list_peers(self) -> list[PeerInfo]:
+        data = self._request("GET", "/peers")
+        return [PeerInfo(**p) for p in data.get("peers", [])]
+
+    def get_peer(self, name: str) -> PeerInfo | None:
+        try:
+            data = self._request("GET", f"/peers/{name}")
+            return PeerInfo(**data)
+        except RegistryClientError as exc:
+            if exc.status == 404:
+                return None
+            raise
+
+    def deregister(self, name: str) -> dict:
+        sig_payload = {"name": name, "action": "deregister"}
+        return self._request(
+            "DELETE", f"/peers/{name}", signature_payload=sig_payload
+        )
+
+
+class RegistryClientError(Exception):
+    """Registry client error with HTTP status and server message."""
+
+    def __init__(self, status: int, message: object):
+        self.status = status
+        self.message = message
+        super().__init__(f"Registry HTTP {status}: {message}")

mesh_peer_registry-0.1.0/mesh_peer_registry/crypto.py

@@ -0,0 +1,87 @@
+"""Ed25519 signature primitives for the mesh peer registry."""
+from __future__ import annotations
+
+import base64
+import json
+from typing import Union
+
+from cryptography.exceptions import InvalidSignature
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric.ed25519 import (
+    Ed25519PrivateKey,
+    Ed25519PublicKey,
+)
+
+__all__ = [
+    "generate_keypair",
+    "sign_message",
+    "verify_message",
+    "canonicalize_payload",
+    "sign_json",
+    "verify_json",
+]
+
+
+def generate_keypair() -> tuple[str, str]:
+    """Generate a new Ed25519 keypair and return (private_key_pem, public_key_pem)."""
+    private_key = Ed25519PrivateKey.generate()
+    public_key = private_key.public_key()
+    private_pem = private_key.private_bytes(
+        encoding=serialization.Encoding.PEM,
+        format=serialization.PrivateFormat.PKCS8,
+        encryption_algorithm=serialization.NoEncryption(),
+    ).decode("utf-8")
+    public_pem = public_key.public_bytes(
+        encoding=serialization.Encoding.PEM,
+        format=serialization.PublicFormat.SubjectPublicKeyInfo,
+    ).decode("utf-8")
+    return private_pem, public_pem
+
+
+def _load_private_key(private_key_pem: str) -> Ed25519PrivateKey:
+    return serialization.load_pem_private_key(
+        private_key_pem.encode("utf-8"), password=None
+    )
+
+
+def _load_public_key(public_key_pem: str) -> Ed25519PublicKey:
+    return serialization.load_pem_public_key(public_key_pem.encode("utf-8"))
+
+
+def sign_message(private_key_pem: str, message: Union[str, bytes]) -> str:
+    """Sign a message and return a base64-encoded signature."""
+    if isinstance(message, str):
+        message = message.encode("utf-8")
+    private_key = _load_private_key(private_key_pem)
+    signature = private_key.sign(message)
+    return base64.b64encode(signature).decode("utf-8")
+
+
+def verify_message(
+    public_key_pem: str, message: Union[str, bytes], signature_b64: str
+) -> bool:
+    """Verify a base64-encoded signature against a message and public key."""
+    if isinstance(message, str):
+        message = message.encode("utf-8")
+    public_key = _load_public_key(public_key_pem)
+    signature = base64.b64decode(signature_b64.encode("utf-8"))
+    try:
+        public_key.verify(signature, message)
+        return True
+    except InvalidSignature:
+        return False
+
+
+def canonicalize_payload(payload: dict) -> bytes:
+    """Return a deterministic JSON encoding of a payload for signing."""
+    return json.dumps(payload, sort_keys=True, separators=(",", ":")).encode("utf-8")
+
+
+def sign_json(private_key_pem: str, payload: dict) -> str:
+    """Sign a JSON-serializable payload and return a base64-encoded signature."""
+    return sign_message(private_key_pem, canonicalize_payload(payload))
+
+
+def verify_json(public_key_pem: str, payload: dict, signature_b64: str) -> bool:
+    """Verify a signature over a JSON-serializable payload."""
+    return verify_message(public_key_pem, canonicalize_payload(payload), signature_b64)

mesh_peer_registry-0.1.0/mesh_peer_registry/models.py

@@ -0,0 +1,15 @@
+"""Data models for the mesh peer registry."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass
+class PeerInfo:
+    """Public peer record held by the registry."""
+
+    name: str
+    url: str
+    public_key: str
+    role: str = "agent"
+    description: str = ""

mesh_peer_registry-0.1.0/mesh_peer_registry/server.py

@@ -0,0 +1,97 @@
+"""HTTP registry server for mesh peers."""
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+
+from aiohttp import web
+
+from .crypto import verify_json
+from .models import PeerInfo
+from .store import FileStore
+
+__all__ = ["create_app"]
+
+AppKeyStore = web.AppKey("store", FileStore)
+
+REGISTRY_FIELDS = {"name", "url", "public_key", "role", "description"}
+REQUIRED_FIELDS = {"name", "url", "public_key"}
+
+
+async def _json_body(request: web.Request) -> dict:
+    try:
+        return await request.json()
+    except json.JSONDecodeError:
+        raise web.HTTPBadRequest(text='{"error": "invalid json"}')
+
+
+async def register(request: web.Request) -> web.Response:
+    body = await _json_body(request)
+    missing = REQUIRED_FIELDS - set(body)
+    if missing:
+        return web.json_response(
+            {"error": f"missing fields: {sorted(missing)}"}, status=400
+        )
+
+    sig = request.headers.get("X-Mesh-Signature", "")
+    if not sig:
+        return web.json_response(
+            {"error": "missing X-Mesh-Signature header"}, status=400
+        )
+
+    payload = {k: body[k] for k in REGISTRY_FIELDS if k in body}
+    public_key = body["public_key"]
+    if not verify_json(public_key, payload, sig):
+        return web.json_response({"error": "invalid signature"}, status=401)
+
+    store: FileStore = request.app[AppKeyStore]
+    store.put(PeerInfo(**payload))
+    return web.json_response({"ok": True, "peer": payload})
+
+
+async def list_peers(request: web.Request) -> web.Response:
+    store: FileStore = request.app[AppKeyStore]
+    peers = store.list()
+    return web.json_response({"peers": [p.__dict__ for p in peers]})
+
+
+async def get_peer(request: web.Request) -> web.Response:
+    name = request.match_info["name"]
+    store: FileStore = request.app[AppKeyStore]
+    peer = store.get(name)
+    if not peer:
+        return web.json_response({"error": "not found"}, status=404)
+    return web.json_response(peer.__dict__)
+
+
+async def delete_peer(request: web.Request) -> web.Response:
+    name = request.match_info["name"]
+    sig = request.headers.get("X-Mesh-Signature", "")
+    if not sig:
+        return web.json_response(
+            {"error": "missing X-Mesh-Signature header"}, status=400
+        )
+
+    store: FileStore = request.app[AppKeyStore]
+    peer = store.get(name)
+    if not peer:
+        return web.json_response({"error": "not found"}, status=404)
+
+    sig_payload = {"name": name, "action": "deregister"}
+    if not verify_json(peer.public_key, sig_payload, sig):
+        return web.json_response({"error": "invalid signature"}, status=401)
+
+    store.delete(name)
+    return web.json_response({"ok": True})
+
+
+def create_app(store_path: str | None = None) -> web.Application:
+    store_path = store_path or os.path.expanduser("~/.mesh/registry.json")
+    app = web.Application()
+    app[AppKeyStore] = FileStore(Path(store_path))
+    app.router.add_post("/register", register)
+    app.router.add_get("/peers", list_peers)
+    app.router.add_get("/peers/{name}", get_peer)
+    app.router.add_delete("/peers/{name}", delete_peer)
+    return app

mesh_peer_registry-0.1.0/mesh_peer_registry/store.py

@@ -0,0 +1,56 @@
+"""Persistence layer for the mesh peer registry."""
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Any
+
+from .models import PeerInfo
+
+
+class FileStore:
+    """Atomic JSON file storage for peer records."""
+
+    def __init__(self, path: str | Path) -> None:
+        self.path = Path(path).expanduser()
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+
+    def _load(self) -> dict[str, Any]:
+        if not self.path.exists():
+            return {}
+        try:
+            return json.loads(self.path.read_text(encoding="utf-8"))
+        except (json.JSONDecodeError, OSError):
+            return {}
+
+    def _save(self, data: dict[str, Any]) -> None:
+        tmp = self.path.with_suffix(".tmp")
+        tmp.write_text(
+            json.dumps(data, sort_keys=True, indent=2),
+            encoding="utf-8",
+        )
+        os.replace(tmp, self.path)
+
+    def get(self, name: str) -> PeerInfo | None:
+        data = self._load()
+        if name not in data:
+            return None
+        return PeerInfo(**data[name])
+
+    def list(self) -> list[PeerInfo]:
+        data = self._load()
+        return [PeerInfo(**v) for _, v in sorted(data.items())]
+
+    def put(self, peer: PeerInfo) -> None:
+        data = self._load()
+        data[peer.name] = peer.__dict__
+        self._save(data)
+
+    def delete(self, name: str) -> bool:
+        data = self._load()
+        if name not in data:
+            return False
+        del data[name]
+        self._save(data)
+        return True

mesh_peer_registry-0.1.0/mesh_peer_registry.egg-info/PKG-INFO

@@ -0,0 +1,121 @@
+Metadata-Version: 2.4
+Name: mesh-peer-registry
+Version: 0.1.0
+Summary: Shared, language-agnostic peer registry for hermes-mesh and openclaw-mesh with Ed25519 signing.
+Author: Emil Tsoi
+License: MIT
+Project-URL: Homepage, https://github.com/emiltsoi/mesh-peer-registry
+Project-URL: Repository, https://github.com/emiltsoi/mesh-peer-registry.git
+Project-URL: Issues, https://github.com/emiltsoi/mesh-peer-registry/issues
+Keywords: mesh,peer,registry,ed25519,aiohttp,openclaw,hermes
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Communications
+Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp>=3.9
+Requires-Dist: cryptography>=41.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+Dynamic: license-file
+
+# mesh-peer-registry
+
+A small, shared, language-agnostic peer registry for the mesh network used by [`hermes-mesh`](https://github.com/emiltsoi/hermes-mesh) and [`openclaw-mesh`](https://github.com/emiltsoi/openclaw-mesh).
+
+Peers register with an Ed25519 public key and a webhook URL, then discover each other over a simple HTTP API. The server never holds private keys.
+
+## About
+
+`mesh-peer-registry` provides a centralized but state-light way for mesh agents to announce themselves to one another:
+
+- Peers register an Ed25519 **public key** and a **webhook URL** under a unique name.
+- Registration and deregistration requests are signed by the peer's private key, so the registry can trust the public key it stores.
+- Other peers query the registry to find a recipient's webhook URL and public key.
+- Mesh messages are signed by the sender and verified by the receiver against the sender's public key from the registry.
+
+The signing protocol uses compact, deterministic, sorted-key JSON, making it straightforward to implement in other runtimes (e.g. the Node.js implementation in `openclaw-mesh`).
+
+## Features
+
+- **HTTP API** for register, list, get, and deregister operations.
+- **Ed25519 signatures** on all mutating requests.
+- **In-memory** store by default, or **file-backed** persistence via `--store`.
+- **CLI** server launcher.
+- **Python client** (`RegistryClient`) with built-in signing.
+- No private keys kept by the registry.
+
+## Quick start
+
+Install and run the server:
+
+```bash
+pip install mesh-peer-registry
+mesh-peer-registry --port 8646 --store ./registry.json
+```
+
+The server will listen on `http://127.0.0.1:8646`.
+
+## API
+
+- `POST /register` — register or update a peer (signed with the peer's private key).
+- `GET /peers` — list all peers.
+- `GET /peers/{name}` — get one peer.
+- `DELETE /peers/{name}` — deregister a peer (signed with the peer's private key).
+
+All registration/deregistration requests must include a valid Ed25519 signature in the `X-Mesh-Signature` header.
+
+## Python client
+
+```python
+from mesh_peer_registry.crypto import generate_keypair
+from mesh_peer_registry.client import RegistryClient
+
+private, public = generate_keypair()
+client = RegistryClient("http://127.0.0.1:8646", private, public)
+
+client.register(
+    "agent0",
+    "http://127.0.0.1:8645/mesh/receive",
+    role="operator",
+    description="Hermes operator node",
+)
+
+print(client.list_peers())
+```
+
+## Verifying a message
+
+```python
+from mesh_peer_registry.crypto import verify_message
+from mesh_peer_registry.client import RegistryClient
+
+client = RegistryClient("http://127.0.0.1:8646", "", "")
+peer = client.get_peer("agent0")
+
+# body is the raw request body; signature is from the X-Mesh-Signature header.
+ok = verify_message(peer.public_key, body, signature)
+```
+
+## Development
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+pip install -e ".[dev]"
+pytest
+```
+
+## License
+
+[MIT](LICENSE)

mesh_peer_registry-0.1.0/mesh_peer_registry.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+LICENSE
+README.md
+pyproject.toml
+mesh_peer_registry/__init__.py
+mesh_peer_registry/cli.py
+mesh_peer_registry/client.py
+mesh_peer_registry/crypto.py
+mesh_peer_registry/models.py
+mesh_peer_registry/server.py
+mesh_peer_registry/store.py
+mesh_peer_registry.egg-info/PKG-INFO
+mesh_peer_registry.egg-info/SOURCES.txt
+mesh_peer_registry.egg-info/dependency_links.txt
+mesh_peer_registry.egg-info/entry_points.txt
+mesh_peer_registry.egg-info/requires.txt
+mesh_peer_registry.egg-info/top_level.txt
+tests/test_registry.py

mesh_peer_registry-0.1.0/mesh_peer_registry.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

mesh_peer_registry-0.1.0/mesh_peer_registry.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mesh-peer-registry = mesh_peer_registry.cli:main

mesh_peer_registry-0.1.0/mesh_peer_registry.egg-info/requires.txt

@@ -0,0 +1,6 @@
+aiohttp>=3.9
+cryptography>=41.0
+
+[dev]
+pytest>=8.0
+pytest-asyncio>=0.23

mesh_peer_registry-0.1.0/mesh_peer_registry.egg-info/top_level.txt

@@ -0,0 +1 @@
+mesh_peer_registry

mesh_peer_registry-0.1.0/pyproject.toml

@@ -0,0 +1,48 @@
+[project]
+name = "mesh-peer-registry"
+version = "0.1.0"
+description = "Shared, language-agnostic peer registry for hermes-mesh and openclaw-mesh with Ed25519 signing."
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.10"
+authors = [{name = "Emil Tsoi"}]
+keywords = ["mesh", "peer", "registry", "ed25519", "aiohttp", "openclaw", "hermes"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Communications",
+    "Topic :: Internet :: WWW/HTTP :: HTTP Servers",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Typing :: Typed",
+]
+dependencies = [
+    "aiohttp>=3.9",
+    "cryptography>=41.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0",
+    "pytest-asyncio>=0.23",
+]
+
+[project.urls]
+Homepage = "https://github.com/emiltsoi/mesh-peer-registry"
+Repository = "https://github.com/emiltsoi/mesh-peer-registry.git"
+Issues = "https://github.com/emiltsoi/mesh-peer-registry/issues"
+
+[project.scripts]
+mesh-peer-registry = "mesh_peer_registry.cli:main"
+
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+packages = ["mesh_peer_registry"]
+license-files = ["LICENSE"]

mesh_peer_registry-0.1.0/setup.cfg

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

mesh_peer_registry-0.1.0/tests/test_registry.py

@@ -0,0 +1,159 @@
+"""Tests for mesh-peer-registry crypto, store, and server."""
+from __future__ import annotations
+
+import asyncio
+import json
+import tempfile
+import unittest
+from pathlib import Path
+
+from aiohttp.test_utils import AioHTTPTestCase
+
+from mesh_peer_registry.client import RegistryClient, RegistryClientError
+from mesh_peer_registry.crypto import (
+    canonicalize_payload,
+    generate_keypair,
+    sign_json,
+    sign_message,
+    verify_json,
+    verify_message,
+)
+from mesh_peer_registry.models import PeerInfo
+from mesh_peer_registry.server import create_app
+from mesh_peer_registry.store import FileStore
+
+
+class TestCrypto(unittest.TestCase):
+    def test_generate_keypair(self):
+        private, public = generate_keypair()
+        assert "BEGIN PRIVATE KEY" in private
+        assert "BEGIN PUBLIC KEY" in public
+
+    def test_sign_and_verify(self):
+        private, public = generate_keypair()
+        sig = sign_message(private, "hello mesh")
+        assert verify_message(public, "hello mesh", sig)
+
+    def test_verify_fails_with_wrong_key(self):
+        private, public = generate_keypair()
+        _, wrong_public = generate_keypair()
+        sig = sign_message(private, "hello")
+        assert not verify_message(wrong_public, "hello", sig)
+
+    def test_verify_fails_with_tampered_message(self):
+        private, public = generate_keypair()
+        sig = sign_message(private, "hello")
+        assert not verify_message(public, "tampered", sig)
+
+    def test_sign_and_verify_json(self):
+        private, public = generate_keypair()
+        payload = {"from": "linda", "to": "britney", "id": "msg-123"}
+        sig = sign_json(private, payload)
+        assert verify_json(public, payload, sig)
+        assert not verify_json(public, {"from": "linda"}, sig)
+
+    def test_canonicalize_is_deterministic(self):
+        a = canonicalize_payload({"b": 2, "a": 1})
+        b = canonicalize_payload({"a": 1, "b": 2})
+        assert a == b
+
+
+class TestStore(unittest.TestCase):
+    def test_put_get_list_delete(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            store = FileStore(Path(tmpdir) / "registry.json")
+            peer = PeerInfo(
+                name="britney",
+                url="http://127.0.0.1:8645",
+                public_key="pk",
+                role="swe",
+            )
+            store.put(peer)
+            fetched = store.get("britney")
+            assert fetched is not None
+            assert fetched.name == "britney"
+            assert store.list()[0].name == "britney"
+            assert store.delete("britney")
+            assert store.get("britney") is None
+
+    def test_delete_missing_returns_false(self):
+        with tempfile.TemporaryDirectory() as tmpdir:
+            store = FileStore(Path(tmpdir) / "registry.json")
+            assert not store.delete("nobody")
+
+
+class TestRegistryServer(AioHTTPTestCase):
+    async def get_application(self):
+        self.tmpdir = tempfile.TemporaryDirectory()
+        return create_app(str(Path(self.tmpdir.name) / "registry.json"))
+
+    def tearDown(self):
+        super().tearDown()
+        if hasattr(self, "tmpdir"):
+            self.tmpdir.cleanup()
+
+    async def test_list_empty(self):
+        resp = await self.client.request("GET", "/peers")
+        assert resp.status == 200
+        body = await resp.json()
+        assert body["peers"] == []
+
+    async def test_register_and_get(self):
+        private, public = generate_keypair()
+        client = RegistryClient(
+            f"http://127.0.0.1:{self.server.port}",
+            private,
+            public,
+        )
+
+        result = await asyncio.to_thread(
+            client.register,
+            name="britney",
+            url="http://127.0.0.1:8645",
+            role="swe",
+            description="Principal",
+        )
+        assert result["ok"]
+
+        peer = await asyncio.to_thread(client.get_peer, "britney")
+        assert peer is not None
+        assert peer.name == "britney"
+        assert peer.role == "swe"
+
+    async def test_register_without_signature_rejected(self):
+        resp = await self.client.request(
+            "POST",
+            "/register",
+            data=json.dumps(
+                {
+                    "name": "britney",
+                    "url": "http://127.0.0.1:8645",
+                    "public_key": "pk",
+                }
+            ),
+            headers={"Content-Type": "application/json"},
+        )
+        assert resp.status == 400
+
+    async def test_deregister(self):
+        private, public = generate_keypair()
+        client = RegistryClient(
+            f"http://127.0.0.1:{self.server.port}",
+            private,
+            public,
+        )
+
+        await asyncio.to_thread(
+            client.register,
+            name="daji",
+            url="http://127.0.0.1:8646",
+            role="agent",
+        )
+        assert (await asyncio.to_thread(client.get_peer, "daji")) is not None
+
+        await asyncio.to_thread(client.deregister, "daji")
+        assert (await asyncio.to_thread(client.get_peer, "daji")) is None
+
+    async def test_get_missing_returns_404(self):
+        resp = await self.client.request("GET", "/peers/nobody")
+        assert resp.status == 404