Source code for fleetmesh_node.protocols.atproto.package

"""fleetmesh-protocol-atproto: Decoupled AT Protocol & XRPC package.

Conforms to ProtocolPackage (fleetmesh_core.wire.interfaces.ProtocolPackage).
Wraps XRPCRouter, FirehoseBroadcaster, and RepoManager, mounting them
onto ProtocolHostRouter with zero external dependencies.
"""
from __future__ import annotations

from typing import Any, Mapping, Optional

from fleetmesh_core.identity.atproto import AtprotoIdentityAdapter
from fleetmesh_core.wire.interfaces import (
    ProtocolHealth,
    ProtocolHostRouter,
    ProtocolIdentityAdapter,
)
from .firehose import FirehoseBroadcaster
from .repo import Repo
from .xrpc import XRPCRouter

__all__ = [
    'AtprotoProtocolPackage',
]


[docs]class AtprotoProtocolPackage: """The AT Protocol (atproto) suite for Fleetmesh.""" name: str = 'atproto' version: str = '1.0.0' standards: tuple[str, ...] = ( 'com.atproto.sync', 'com.atproto.repo', 'com.atproto.server', 'did:plc', 'did:web', 'dag-cbor', 'mst', )
[docs] def __init__( self, repo: Optional[Repo] = None, keystore: Optional[Any] = None, service_domain: str = "node.fleetmesh.local", firehose: Optional[FirehoseBroadcaster] = None, blob_store: Optional[Any] = None, ): self.repo = repo self.keystore = keystore self.service_domain = service_domain self.firehose = firehose or FirehoseBroadcaster() self.blob_store = blob_store self.config: Mapping[str, Any] = {} self._enabled: bool = True self._host: Optional[ProtocolHostRouter] = None self.xrpc_router: Optional[XRPCRouter] = None
[docs] def configure(self, config: Mapping[str, Any]) -> None: self.config = dict(config) self._enabled = self.config.get('enabled', True) if 'service_domain' in self.config: self.service_domain = self.config['service_domain']
[docs] def identity_adapter(self, keystore: Any) -> Optional[ProtocolIdentityAdapter]: ks = keystore or self.keystore if ks is None: return None did_val = self.repo.did if self.repo else None return AtprotoIdentityAdapter(keystore=ks, handle=self.service_domain, did=did_val)
[docs] def mount_ingress(self, host: ProtocolHostRouter) -> None: if not self._enabled: return self._host = host if self.xrpc_router is None: self.xrpc_router = XRPCRouter(repo=self.repo, service_domain=self.service_domain) router = self.xrpc_router # 1. XRPC HTTP endpoints under /xrpc def _handle_xrpc_http(conn: Any, req: Any) -> bool: from fleetmesh_node.transport import ws method = getattr(req, 'method', 'GET') path = getattr(req, 'path', '') body = getattr(req, 'body', None) if body is None: body = ws.read_body(conn, req) status, headers, resp_body = router.handle_request(method, path, body) ws.http_response( conn, f"{status} OK" if status == 200 else f"{status} Error", resp_body, headers.get('Content-Type', 'application/json'), ) return True host.mount_route('/xrpc', _handle_xrpc_http, methods=('GET', 'POST'), owner=self.name) # 2. Firehose WebSocket under /xrpc/com.atproto.sync.subscribeRepos def _handle_firehose_ws(ws_conn: Any, path: str) -> None: self.firehose.subscribe(ws_conn) host.mount_websocket('/xrpc/com.atproto.sync.subscribeRepos', _handle_firehose_ws, owner=self.name) # 3. Well-known DID endpoint def _handle_well_known_did(conn: Any, req: Any) -> bool: did_str = self.repo.did if self.repo else f"did:web:{self.service_domain}" from fleetmesh_node.transport import ws ws.http_response(conn, "200 OK", did_str.encode('utf-8'), 'text/plain') return True host.mount_route('/.well-known/atproto-did', _handle_well_known_did, methods=('GET',), owner=self.name)
[docs] def transport_rung(self, context: Any) -> Optional[Any]: # ATProto does not operate as a direct transport ladder rung for DIDComm/Nostr return None
[docs] def compartments(self) -> tuple[type[Any], ...]: return ()
[docs] def start(self) -> None: pass
[docs] def stop(self) -> None: pass
[docs] def health(self) -> ProtocolHealth: if not self._enabled: return ProtocolHealth( healthy=True, status="disabled", connections_active=0, messages_in=0, messages_out=0, errors=(), ) subs = self.firehose.subscriber_count return ProtocolHealth( healthy=True, status="serving", connections_active=subs, messages_in=0, messages_out=self.firehose.current_seq - 1, errors=(), )
[docs] def descriptor_capabilities(self) -> tuple[tuple[str, str], ...]: if not self._enabled: return () caps = [('c', 'atproto'), ('c', 'xrpc')] if self.firehose is not None: caps.append(('c', 'firehose')) return tuple(caps)