fleetmesh-node 0.2.0__py3-none-any.whl

node/protocols/atproto/xrpc.py

@@ -0,0 +1,285 @@
+"""AT Protocol XRPC (XML-less RPC) server and endpoint router.
+
+Standard library only. Routes XRPC queries (GET) and procedures (POST)
+under `/xrpc/<nsid>`, handling core ATProto Lexicons:
+- com.atproto.server.describeServer
+- com.atproto.repo.describeRepo
+- com.atproto.repo.getRecord
+- com.atproto.repo.listRecords
+- com.atproto.repo.createRecord
+- com.atproto.repo.deleteRecord
+- com.atproto.sync.getRepo
+- com.atproto.sync.getLatestCommit
+- com.atproto.sync.getBlob
+"""
+from __future__ import annotations
+
+import json
+import re
+import urllib.parse
+from typing import Callable, Mapping, Optional
+
+from fleetmesh_core.conformance.errors import FleetmeshError
+from .repo import Repo
+
+VALID_COLLECTION_RE = re.compile(r'^[a-zA-Z0-9.-]{1,512}$')
+VALID_RKEY_RE = re.compile(r'^[a-zA-Z0-9._~-]{1,512}$')
+
+__all__ = [
+    'XRPCError',
+    'XRPCRouter',
+]
+
+
+class XRPCError(FleetmeshError):
+    """Represents an XRPC error with HTTP status and Lexicon error string."""
+
+    def __init__(self, status: int, error: str, message: str):
+        super().__init__(f"{error}: {message}")
+        self.status = status
+        self.error = error
+        self.message = message
+
+    def to_dict(self) -> dict[str, str]:
+        return {'error': self.error, 'message': self.message}
+
+
+class XRPCRouter:
+    """Dispatches XRPC queries and procedures to registered Lexicon handlers."""
+
+    def __init__(
+        self,
+        repo: Optional[Repo] = None,
+        service_domain: str = "node.fleetmesh.local",
+    ):
+        self.repo = repo
+        self.service_domain = service_domain
+        self._queries: dict[str, Callable[[dict[str, list[str]], bytes], tuple[int, str, bytes]]] = {}
+        self._procedures: dict[str, Callable[[dict[str, list[str]], bytes], tuple[int, str, bytes]]] = {}
+        self._register_default_lexicons()
+
+    def register_query(
+        self,
+        nsid: str,
+        handler: Callable[[dict[str, list[str]], bytes], tuple[int, str, bytes]],
+    ) -> None:
+        """Register a GET XRPC query handler."""
+        self._queries[nsid] = handler
+
+    def register_procedure(
+        self,
+        nsid: str,
+        handler: Callable[[dict[str, list[str]], bytes], tuple[int, str, bytes]],
+    ) -> None:
+        """Register a POST XRPC procedure handler."""
+        self._procedures[nsid] = handler
+
+    def _register_default_lexicons(self) -> None:
+        self.register_query('com.atproto.server.describeServer', self._describe_server)
+        self.register_query('com.atproto.repo.describeRepo', self._describe_repo)
+        self.register_query('com.atproto.repo.getRecord', self._get_record)
+        self.register_query('com.atproto.repo.listRecords', self._list_records)
+        self.register_procedure('com.atproto.repo.createRecord', self._create_record)
+        self.register_procedure('com.atproto.repo.deleteRecord', self._delete_record)
+        self.register_query('com.atproto.sync.getRepo', self._get_repo_car)
+        self.register_query('com.atproto.sync.getLatestCommit', self._get_latest_commit)
+        self.register_query('com.atproto.sync.getBlob', self._get_blob)
+
+    def handle_request(
+        self,
+        method: str,
+        raw_path: str,
+        body: bytes = b"",
+    ) -> tuple[int, Mapping[str, str], bytes]:
+        """Dispatch HTTP request to XRPC handler.
+
+        Returns (status_code, headers_dict, body_bytes).
+        """
+        parsed = urllib.parse.urlparse(raw_path)
+        path = parsed.path
+        if not path.startswith('/xrpc/'):
+            return 404, {'Content-Type': 'application/json'}, json.dumps({'error': 'NotFound', 'message': 'Not an XRPC endpoint'}).encode()
+
+        nsid = path[len('/xrpc/'):].strip('/')
+        params = urllib.parse.parse_qs(parsed.query)
+
+        try:
+            if method == 'GET':
+                if nsid not in self._queries:
+                    return 404, {'Content-Type': 'application/json'}, json.dumps({'error': 'MethodNotImplemented', 'message': f"Query {nsid} not implemented"}).encode()
+                status, content_type, resp_body = self._queries[nsid](params, body)
+                return status, {'Content-Type': content_type}, resp_body
+            elif method == 'POST':
+                if nsid not in self._procedures:
+                    return 404, {'Content-Type': 'application/json'}, json.dumps({'error': 'MethodNotImplemented', 'message': f"Procedure {nsid} not implemented"}).encode()
+                status, content_type, resp_body = self._procedures[nsid](params, body)
+                return status, {'Content-Type': content_type}, resp_body
+            else:
+                return 405, {'Allow': 'GET, POST', 'Content-Type': 'application/json'}, json.dumps({'error': 'MethodNotAllowed', 'message': f"HTTP {method} not allowed"}).encode()
+        except XRPCError as e:
+            return e.status, {'Content-Type': 'application/json'}, json.dumps(e.to_dict()).encode()
+        except Exception as e:
+            return 500, {'Content-Type': 'application/json'}, json.dumps({'error': 'InternalServerError', 'message': str(e)}).encode()
+
+    # --- Core Lexicon Handlers ---
+
+    def _describe_server(self, params: dict[str, list[str]], body: bytes) -> tuple[int, str, bytes]:
+        data = {
+            'availableUserDomains': [self.service_domain],
+            'inviteCodeRequired': False,
+            'links': {
+                'privacyPolicy': f"https://{self.service_domain}/privacy",
+                'termsOfService': f"https://{self.service_domain}/tos",
+            },
+        }
+        return 200, 'application/json', json.dumps(data).encode()
+
+    def _describe_repo(self, params: dict[str, list[str]], body: bytes) -> tuple[int, str, bytes]:
+        if self.repo is None:
+            raise XRPCError(404, 'RepoNotFound', 'No repository hosted on this node')
+        repo_param = params.get('repo', [self.repo.did])[0]
+        if repo_param != self.repo.did:
+            raise XRPCError(404, 'RepoNotFound', f"Repo {repo_param} not found")
+
+        records = self.repo.list_records()
+        collections = sorted(list(set(c for c, _, _, _ in records)))
+        data = {
+            'did': self.repo.did,
+            'handle': self.service_domain,
+            'didDoc': None,
+            'collections': collections,
+            'handleIsCorrect': True,
+        }
+        return 200, 'application/json', json.dumps(data).encode()
+
+    def _get_record(self, params: dict[str, list[str]], body: bytes) -> tuple[int, str, bytes]:
+        repo_val = params.get('repo', [''])[0]
+        col_val = params.get('collection', [''])[0]
+        rkey_val = params.get('rkey', [''])[0]
+
+        if not col_val or not rkey_val:
+            raise XRPCError(400, 'InvalidRequest', 'Missing required params: collection and rkey')
+        if not VALID_COLLECTION_RE.match(col_val):
+            raise XRPCError(400, 'InvalidRequest', f"Malformed collection format: {col_val}")
+        if not VALID_RKEY_RE.match(rkey_val):
+            raise XRPCError(400, 'InvalidRequest', f"Malformed rkey format: {rkey_val}")
+
+        if self.repo is None:
+            raise XRPCError(404, 'RepoNotFound', 'No repository hosted on this node')
+        if repo_val and repo_val != self.repo.did:
+            raise XRPCError(404, 'RepoNotFound', f"Unknown repo: {repo_val}")
+
+        record_info = self.repo.get_record(col_val, rkey_val)
+        if record_info is None:
+            raise XRPCError(404, 'RecordNotFound', f"Record {col_val}/{rkey_val} not found")
+
+        rec_cid, rec_doc = record_info
+        out = {
+            'uri': f"at://{self.repo.did}/{col_val}/{rkey_val}",
+            'cid': rec_cid.cid_str,
+            'value': rec_doc,
+        }
+        return 200, 'application/json', json.dumps(out).encode()
+
+    def _list_records(self, params: dict[str, list[str]], body: bytes) -> tuple[int, str, bytes]:
+        col_val = params.get('collection', [''])[0]
+        if not col_val:
+            raise XRPCError(400, 'InvalidRequest', 'Missing required param: collection')
+        if not VALID_COLLECTION_RE.match(col_val):
+            raise XRPCError(400, 'InvalidRequest', f"Malformed collection format: {col_val}")
+
+        if self.repo is None:
+            raise XRPCError(404, 'RepoNotFound', 'No repository hosted on this node')
+
+        limit = 50
+        if 'limit' in params:
+            try:
+                limit = min(100, max(1, int(params['limit'][0])))
+            except ValueError:
+                pass
+
+        records = self.repo.list_records(col_val)[:limit]
+        out_records = []
+        for col, rkey, cid, doc in records:
+            out_records.append({
+                'uri': f"at://{self.repo.did}/{col}/{rkey}",
+                'cid': cid.cid_str,
+                'value': doc,
+            })
+        return 200, 'application/json', json.dumps({'records': out_records}).encode()
+
+    def _create_record(self, params: dict[str, list[str]], body: bytes) -> tuple[int, str, bytes]:
+        try:
+            req_data = json.loads(body.decode('utf-8'))
+        except Exception:
+            raise XRPCError(400, 'InvalidJson', 'Invalid JSON body')
+
+        col = req_data.get('collection')
+        rec = req_data.get('record')
+        rkey = req_data.get('rkey')
+        if not col or not rec:
+            raise XRPCError(400, 'InvalidRequest', 'Missing collection or record in body')
+        if not VALID_COLLECTION_RE.match(col):
+            raise XRPCError(400, 'InvalidRequest', f"Malformed collection format: {col}")
+        if rkey is not None and not VALID_RKEY_RE.match(rkey):
+            raise XRPCError(400, 'InvalidRequest', f"Malformed rkey format: {rkey}")
+
+        if self.repo is None:
+            raise XRPCError(404, 'RepoNotFound', 'No repository hosted on this node')
+
+        assigned_rkey, rec_cid, commit_cid = self.repo.put_record(col, rec, rkey=rkey)
+        out = {
+            'uri': f"at://{self.repo.did}/{col}/{assigned_rkey}",
+            'cid': rec_cid.cid_str,
+            'commit': {'cid': commit_cid.cid_str, 'rev': self.repo.head_commit_cid.cid_str if self.repo.head_commit_cid else ''},
+        }
+        return 200, 'application/json', json.dumps(out).encode()
+
+    def _delete_record(self, params: dict[str, list[str]], body: bytes) -> tuple[int, str, bytes]:
+        try:
+            req_data = json.loads(body.decode('utf-8'))
+        except Exception:
+            raise XRPCError(400, 'InvalidJson', 'Invalid JSON body')
+
+        col = req_data.get('collection')
+        rkey = req_data.get('rkey')
+        if not col or not rkey:
+            raise XRPCError(400, 'InvalidRequest', 'Missing collection or rkey in body')
+        if not VALID_COLLECTION_RE.match(col):
+            raise XRPCError(400, 'InvalidRequest', f"Malformed collection format: {col}")
+        if not VALID_RKEY_RE.match(rkey):
+            raise XRPCError(400, 'InvalidRequest', f"Malformed rkey format: {rkey}")
+
+        if self.repo is None:
+            raise XRPCError(404, 'RepoNotFound', 'No repository hosted on this node')
+
+        commit_cid = self.repo.delete_record(col, rkey)
+        out = {'commit': {'cid': commit_cid.cid_str}}
+        return 200, 'application/json', json.dumps(out).encode()
+
+    def _get_repo_car(self, params: dict[str, list[str]], body: bytes) -> tuple[int, str, bytes]:
+        if self.repo is None:
+            raise XRPCError(404, 'RepoNotFound', 'No repository hosted on this node')
+        car_bytes = self.repo.export_car()
+        return 200, 'application/vnd.ipld.car', car_bytes
+
+    def _get_latest_commit(self, params: dict[str, list[str]], body: bytes) -> tuple[int, str, bytes]:
+        if self.repo is None or self.repo.head_commit_cid is None:
+            raise XRPCError(404, 'RepoNotFound', 'Repository has no commits')
+        out = {
+            'cid': self.repo.head_commit_cid.cid_str,
+            'rev': self.repo.head_commit_cid.cid_str,
+        }
+        return 200, 'application/json', json.dumps(out).encode()
+
+    def _get_blob(self, params: dict[str, list[str]], body: bytes) -> tuple[int, str, bytes]:
+        if self.repo is None:
+            raise XRPCError(404, 'RepoNotFound', 'No repository hosted on this node')
+        cid_str = params.get('cid', [''])[0]
+        if not cid_str:
+            raise XRPCError(400, 'InvalidRequest', 'Missing cid param')
+
+        data = self.repo.get_blob(cid_str)
+        if data is None:
+            raise XRPCError(404, 'BlobNotFound', f"Blob {cid_str} not found")
+        return 200, 'application/octet-stream', data

node/protocols/base.py

@@ -0,0 +1,109 @@
+"""Shared base classes for Fleetmesh protocol adapters."""
+from __future__ import annotations
+
+from typing import Any, Optional, TypeVar
+
+from cryptography.exceptions import InvalidSignature
+from cryptography.hazmat.primitives.asymmetric import ed25519
+
+from fleetmesh_core.crypto import keys
+from fleetmesh_core.wire import spelling
+from fleetmesh_core.wire.interfaces import ProtocolIdentityAdapter
+
+__all__ = [
+    'BaseProtocolPackage',
+    'Ed25519IdentityAdapter',
+]
+
+T = TypeVar('T', bound='Ed25519IdentityAdapter')
+
+
+class BaseProtocolPackage:
+    """Shared base class for Fleetmesh protocol packages."""
+
+    store: Any = None
+
+    def stop(self) -> None:
+        """Close any attached protocol store when stopping the package."""
+        store_obj = getattr(self, 'store', None)
+        if store_obj is not None and hasattr(store_obj, 'close'):
+            store_obj.close()
+
+
+class Ed25519IdentityAdapter(ProtocolIdentityAdapter):
+    """Shared Ed25519 identity and assertion adapter for protocol packages."""
+
+    uri_prefixes: tuple[str, ...] = ()
+
+    def __init__(
+        self,
+        private_key: Any = None,
+        public_key_hex: Optional[str] = None,
+    ) -> None:
+        self.private_key = private_key
+        self._private_key = private_key
+        if private_key is not None and hasattr(private_key, 'public_key'):
+            self._public_key_hex = private_key.public_key().public_bytes_raw().hex()
+        else:
+            self._public_key_hex = public_key_hex.lower() if public_key_hex else ""
+
+    @property
+    def author_id(self) -> str:
+        """The canonical 64-character lowercase hex author identifier."""
+        return self._public_key_hex
+
+    def resolve_id(self, uri: str) -> Optional[str]:
+        """Resolve a protocol URI or raw 64-char hex public key to a canonical ID."""
+        clean = uri.strip()
+        for prefix in self.uri_prefixes:
+            if clean.startswith(prefix):
+                clean = clean[len(prefix):]
+                break
+        if spelling.is_hex(clean, 64, upper=True):
+            return clean.lower()
+        return None
+
+    def sign_assertion(self, payload: bytes) -> bytes:
+        """Sign payload bytes using the configured Ed25519 private key."""
+        key = self.private_key if self.private_key is not None else self._private_key
+        if key is None:
+            raise RuntimeError("Private key not configured for signing assertions")
+        if hasattr(key, 'sign'):
+            return key.sign(payload)
+        k = ed25519.Ed25519PrivateKey.from_private_bytes(bytes(key))
+        return k.sign(payload)
+
+    @staticmethod
+    def _verify_ed25519_bytes(payload: bytes, signature: bytes, raw_pub: bytes) -> bool:
+        try:
+            verifier = ed25519.Ed25519PublicKey.from_public_bytes(raw_pub)
+            verifier.verify(signature, payload)
+            return True
+        except (InvalidSignature, ValueError, TypeError):
+            return False
+
+    def verify_assertion(self, payload: bytes, signature: bytes, pubkey: str) -> bool:
+        """Verify an assertion signature against an Ed25519 public key."""
+        resolved = self.resolve_id(pubkey)
+        if resolved is None:
+            return False
+        try:
+            raw_pub = bytes.fromhex(resolved)
+        except ValueError:
+            return False
+        return self._verify_ed25519_bytes(payload, signature, raw_pub)
+
+    @classmethod
+    def from_keystore(cls: type[T], keystore: Any) -> T:
+        """Construct adapter from a Fleetmesh Keystore instance."""
+        if hasattr(keystore, 'transport_seed') and keystore.transport_seed:
+            priv, _ = keys.transport_keypair(keystore.transport_seed)
+            return cls(private_key=priv)
+        if hasattr(keystore, 'transport_priv') and keystore.transport_priv is not None:
+            return cls(private_key=keystore.transport_priv)
+        if hasattr(keystore, 'ed25519_sk') and keystore.ed25519_sk is not None:
+            return cls(private_key=keystore.ed25519_sk)
+        if hasattr(keystore, 'transport_pub') and keystore.transport_pub:
+            raw_pub = keys.raw_public(keystore.transport_pub)
+            return cls(public_key_hex=raw_pub.hex())
+        return cls()

node/protocols/circles/__init__.py

@@ -0,0 +1,29 @@
+"""FleetMesh Node Circles Protocol Package (`node.protocols.circles`)."""
+from __future__ import annotations
+
+# The stores and route handlers live in the fleetmesh-protocols package
+# (fleetmesh_protocols.circles); this package re-exports them so node code and
+# the protocol router keep their import paths.
+
+from fleetmesh_protocols.circles.persistence import load_circles, persist_circle
+from fleetmesh_protocols.circles.store import (
+    apply_circle_media_privacy,
+    circle_access,
+    handle_circles_post,
+    is_circle_member,
+    visible_circle,
+    visible_circles,
+    visible_invites,
+)
+
+__all__ = [
+    "load_circles",
+    "persist_circle",
+    "apply_circle_media_privacy",
+    "circle_access",
+    "handle_circles_post",
+    "is_circle_member",
+    "visible_circle",
+    "visible_circles",
+    "visible_invites",
+]

node/protocols/dm/__init__.py

@@ -0,0 +1,50 @@
+"""FleetMesh Node Direct-Message Mailbox & Spool Package (`node.protocols.dm`)."""
+from __future__ import annotations
+
+# The stores and route handlers live in the fleetmesh-protocols package
+# (fleetmesh_protocols.dm); this package re-exports them so node code and
+# the protocol router keep their import paths.
+
+from fleetmesh_protocols.dm.mailbox import (
+    MAX_SEALED_CONTENT,
+    ensure_mailbox,
+    get_dm_summary,
+    load_dm_mailbox,
+    peer_records,
+    persist_dm_message,
+    persist_dm_view,
+    persist_leaf_binding,
+    record_message,
+    update_view,
+    viewer_conversations,
+    viewer_envelopes,
+    viewer_messages,
+)
+from fleetmesh_protocols.dm.spool import (
+    ensure_dm_spool_fields,
+    get_active_typing_indicators,
+    get_dm_peers,
+    handle_dm_post,
+    record_typing_indicator,
+)
+
+__all__ = [
+    "MAX_SEALED_CONTENT",
+    "ensure_mailbox",
+    "get_dm_summary",
+    "load_dm_mailbox",
+    "peer_records",
+    "persist_dm_message",
+    "persist_dm_view",
+    "persist_leaf_binding",
+    "record_message",
+    "update_view",
+    "viewer_conversations",
+    "viewer_envelopes",
+    "viewer_messages",
+    "ensure_dm_spool_fields",
+    "get_active_typing_indicators",
+    "get_dm_peers",
+    "handle_dm_post",
+    "record_typing_indicator",
+]

node/protocols/grasp/__init__.py

@@ -0,0 +1,22 @@
+"""FleetMesh Node GRASP Git Protocol Package (`node.protocols.grasp`)."""
+from __future__ import annotations
+
+# The stores and route handlers live in the fleetmesh-protocols package
+# (fleetmesh_protocols.grasp); this package re-exports them so node code and
+# the protocol router keep their import paths.
+
+from fleetmesh_protocols.grasp.git_http import _pkt_line, handle_git_smart_http, render_node_portal_html
+from fleetmesh_protocols.grasp.git_store import SEED_EPOCH, StandaloneGraspGitStore, _clean_slug, _commit_time, handle_grasp_api_http
+from fleetmesh_protocols.grasp.seeds import SEEDED_GRASP_REPOS
+
+__all__ = [
+    "SEEDED_GRASP_REPOS",
+    "SEED_EPOCH",
+    "StandaloneGraspGitStore",
+    "_clean_slug",
+    "_commit_time",
+    "handle_grasp_api_http",
+    "_pkt_line",
+    "handle_git_smart_http",
+    "render_node_portal_html",
+]

node/protocols/isotime.py

@@ -0,0 +1,15 @@
+"""The timestamp text the protocol stores write: UTC, whole seconds, a Z.
+
+Four stores wrote this function out for themselves, byte for byte (audit
+2026-10-15, D8). It reads the wall clock, as all four did: what it stamps is
+when a row was written, for an operator reading the table, never a protocol
+time another node compares.
+"""
+from __future__ import annotations
+
+import datetime
+
+
+def now_iso() -> str:
+    """Now, as 2026-10-15T09:20:00Z."""
+    return datetime.datetime.now(datetime.timezone.utc).strftime('%Y-%m-%dT%H:%M:%SZ')

node/protocols/nostr/__init__.py

@@ -0,0 +1,51 @@
+"""Nostr & Blossom protocol package for Fleetmesh.
+
+Supports:
+- NIP-01..NIP-77 relay server, event store, and client connections.
+- BUD-01..BUD-04 Blossom blob storage and media servers.
+- Peer descriptor exchange and cryptographic identity assertions.
+- Unified ProtocolPackage ingress and lifecycle management.
+"""
+from __future__ import annotations
+
+from typing import Any
+
+from .client import DEAD_AFTER, PING_AFTER, Relay, RelayError, publish_all, query_all
+
+__all__ = [
+    'DEAD_AFTER', 'PING_AFTER', 'Relay', 'RelayError', 'publish_all', 'query_all',
+    'RelayServer', 'NodeStore', 'BlossomServer', 'BlossomClient', 'BlobStore', 'Peers',
+    'NostrProtocolPackage', 'NostrIdentityAdapter',
+    'blobstore', 'blossom', 'client', 'descriptor', 'eventstore', 'package', 'peers', 'relayserver',
+]
+
+
+def __getattr__(name: str) -> Any:
+    if name == 'RelayServer':
+        from .relayserver import RelayServer
+        return RelayServer
+    if name == 'NodeStore':
+        from .eventstore import NodeStore
+        return NodeStore
+    if name == 'BlossomServer':
+        from .blossom import BlossomServer
+        return BlossomServer
+    if name == 'BlossomClient':
+        from .blossom import BlossomClient
+        return BlossomClient
+    if name == 'BlobStore':
+        from .blobstore import BlobStore
+        return BlobStore
+    if name == 'Peers':
+        from .peers import Peers
+        return Peers
+    if name == 'NostrProtocolPackage':
+        from .package import NostrProtocolPackage
+        return NostrProtocolPackage
+    if name == 'NostrIdentityAdapter':
+        from .package import NostrIdentityAdapter
+        return NostrIdentityAdapter
+    if name in ('blobstore', 'blossom', 'client', 'descriptor', 'eventstore', 'package', 'peers', 'relayserver'):
+        import importlib
+        return importlib.import_module(f'.{name}', __package__)
+    raise AttributeError(f"module '{__name__}' has no attribute '{name}'")