"""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 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)