fleetmesh-node 0.2.0__py3-none-any.whl

node/protocols/activitypub/models.py

@@ -0,0 +1,286 @@
+"""ActivityStreams 2.0 object and activity models.
+
+Standard library only. Defines:
+- Core ActivityStreams 2.0 objects: Note, Article, Image, Document.
+- Core ActivityPub activities: Create, Follow, Accept, Undo, Delete, Announce, Like.
+- Serialization and parsing helpers with schema validation.
+"""
+from __future__ import annotations
+
+import json
+from typing import Any, Mapping, Optional, Sequence, Union
+
+from fleetmesh_core.conformance.errors import FleetmeshError
+
+__all__ = [
+    'ActivityPubError',
+    'AS_CONTEXT',
+    'SECURITY_CONTEXT',
+    'Activity',
+    'Note',
+    'parse_activity',
+    'build_note',
+    'build_create_activity',
+    'build_follow_activity',
+    'build_accept_activity',
+    'build_undo_activity',
+    'build_delete_activity',
+    'build_announce_activity',
+]
+
+AS_CONTEXT = "https://www.w3.org/ns/activitystreams"
+SECURITY_CONTEXT = "https://w3id.org/security/v1"
+PUBLIC_COLLECTION = "https://www.w3.org/ns/activitystreams#Public"
+
+
+class ActivityPubError(FleetmeshError):
+    """Base error for ActivityPub data and parsing."""
+
+
+from node.protocols.isotime import now_iso as _now_iso  # noqa: E402
+
+
+class Note:
+    """An ActivityStreams Note object (microblog post)."""
+
+    def __init__(
+        self,
+        id: str,
+        attributed_to: str,
+        content: str,
+        to: Optional[Sequence[str]] = None,
+        cc: Optional[Sequence[str]] = None,
+        published: Optional[str] = None,
+        in_reply_to: Optional[str] = None,
+        attachment: Optional[Sequence[Mapping[str, Any]]] = None,
+        url: Optional[str] = None,
+    ):
+        self.id = id
+        self.attributed_to = attributed_to
+        self.content = content
+        self.to = list(to) if to is not None else [PUBLIC_COLLECTION]
+        self.cc = list(cc) if cc is not None else []
+        self.published = published or _now_iso()
+        self.in_reply_to = in_reply_to
+        self.attachment = list(attachment) if attachment is not None else []
+        self.url = url or id
+
+    def to_dict(self) -> Mapping[str, Any]:
+        doc = {
+            '@context': AS_CONTEXT,
+            'id': self.id,
+            'type': 'Note',
+            'attributedTo': self.attributed_to,
+            'content': self.content,
+            'to': self.to,
+            'cc': self.cc,
+            'published': self.published,
+            'url': self.url,
+            **({'inReplyTo': self.in_reply_to} if self.in_reply_to else {}),
+            **({'attachment': self.attachment} if self.attachment else {}),
+        }
+        return doc
+
+
+class Activity:
+    """An ActivityStreams Activity (Create, Follow, Accept, Undo, etc.)."""
+
+    def __init__(
+        self,
+        id: str,
+        type: str,
+        actor: str,
+        object: Union[str, Mapping[str, Any]],
+        to: Optional[Sequence[str]] = None,
+        cc: Optional[Sequence[str]] = None,
+        published: Optional[str] = None,
+    ):
+        self.id = id
+        self.type = type
+        self.actor = actor
+        self.object = object
+        self.to = list(to) if to is not None else [PUBLIC_COLLECTION]
+        self.cc = list(cc) if cc is not None else []
+        self.published = published or _now_iso()
+
+    @property
+    def object_id(self) -> str:
+        """Extract object ID whether object is a string URI or embedded dict."""
+        if isinstance(self.object, dict):
+            return self.object.get('id', '')
+        return str(self.object)
+
+    def to_dict(self) -> Mapping[str, Any]:
+        return {
+            '@context': AS_CONTEXT,
+            'id': self.id,
+            'type': self.type,
+            'actor': self.actor,
+            'object': self.object,
+            'to': self.to,
+            'cc': self.cc,
+            'published': self.published,
+        }
+
+
+def parse_activity(data: Union[str, bytes, Mapping[str, Any]]) -> Activity:
+    """Parse JSON or dict into an Activity instance."""
+    if isinstance(data, (str, bytes)):
+        try:
+            doc = json.loads(data)
+        except Exception as e:
+            raise ActivityPubError(f"invalid JSON: {e}") from e
+    else:
+        doc = dict(data)
+
+    if not isinstance(doc, dict):
+        raise ActivityPubError("activity must be a JSON object")
+
+    act_type = doc.get('type')
+    if not act_type or not isinstance(act_type, str):
+        raise ActivityPubError("activity lacks valid type")
+
+    actor = doc.get('actor')
+    if not actor:
+        raise ActivityPubError("activity lacks actor")
+
+    act_id = doc.get('id', '')
+    obj = doc.get('object', '')
+    to = doc.get('to')
+    cc = doc.get('cc')
+    pub = doc.get('published')
+
+    to_list = [to] if isinstance(to, str) else list(to) if isinstance(to, list) else None
+    cc_list = [cc] if isinstance(cc, str) else list(cc) if isinstance(cc, list) else None
+
+    return Activity(
+        id=act_id,
+        type=act_type,
+        actor=actor,
+        object=obj,
+        to=to_list,
+        cc=cc_list,
+        published=pub,
+    )
+
+
+def build_note(
+    id: str,
+    attributed_to: str,
+    content: str,
+    to: Optional[Sequence[str]] = None,
+    cc: Optional[Sequence[str]] = None,
+    in_reply_to: Optional[str] = None,
+    attachment: Optional[Sequence[Mapping[str, Any]]] = None,
+) -> Mapping[str, Any]:
+    """Helper to build a standard Note dictionary."""
+    return Note(
+        id=id,
+        attributed_to=attributed_to,
+        content=content,
+        to=to,
+        cc=cc,
+        in_reply_to=in_reply_to,
+        attachment=attachment,
+    ).to_dict()
+
+
+def build_create_activity(
+    activity_id: str,
+    actor_uri: str,
+    note_or_object: Mapping[str, Any],
+    to: Optional[Sequence[str]] = None,
+    cc: Optional[Sequence[str]] = None,
+) -> Mapping[str, Any]:
+    """Wrap an object in a Create activity."""
+    return Activity(
+        id=activity_id,
+        type='Create',
+        actor=actor_uri,
+        object=note_or_object,
+        to=to or note_or_object.get('to'),
+        cc=cc or note_or_object.get('cc'),
+    ).to_dict()
+
+
+def build_follow_activity(
+    activity_id: str,
+    actor_uri: str,
+    target_actor_uri: str,
+) -> Mapping[str, Any]:
+    """Build a Follow activity targeting another actor."""
+    return Activity(
+        id=activity_id,
+        type='Follow',
+        actor=actor_uri,
+        object=target_actor_uri,
+        to=[target_actor_uri],
+        cc=[],
+    ).to_dict()
+
+
+def build_accept_activity(
+    activity_id: str,
+    actor_uri: str,
+    follow_activity: Union[str, Mapping[str, Any]],
+    recipient_uri: str,
+) -> Mapping[str, Any]:
+    """Build an Accept activity responding to a Follow."""
+    return Activity(
+        id=activity_id,
+        type='Accept',
+        actor=actor_uri,
+        object=follow_activity,
+        to=[recipient_uri],
+        cc=[],
+    ).to_dict()
+
+
+def build_undo_activity(
+    activity_id: str,
+    actor_uri: str,
+    activity_to_undo: Union[str, Mapping[str, Any]],
+    recipient_uri: Optional[str] = None,
+) -> Mapping[str, Any]:
+    """Build an Undo activity (e.g. unfollow or unlike)."""
+    to_list = [recipient_uri] if recipient_uri else [PUBLIC_COLLECTION]
+    return Activity(
+        id=activity_id,
+        type='Undo',
+        actor=actor_uri,
+        object=activity_to_undo,
+        to=to_list,
+        cc=[],
+    ).to_dict()
+
+
+def build_delete_activity(
+    activity_id: str,
+    actor_uri: str,
+    object_uri: str,
+) -> Mapping[str, Any]:
+    """Build a Delete activity removing a previously published object."""
+    return Activity(
+        id=activity_id,
+        type='Delete',
+        actor=actor_uri,
+        object=object_uri,
+        to=[PUBLIC_COLLECTION],
+        cc=[],
+    ).to_dict()
+
+
+def build_announce_activity(
+    activity_id: str,
+    actor_uri: str,
+    object_uri: str,
+) -> Mapping[str, Any]:
+    """Build an Announce (boost/repost) activity."""
+    return Activity(
+        id=activity_id,
+        type='Announce',
+        actor=actor_uri,
+        object=object_uri,
+        to=[PUBLIC_COLLECTION],
+        cc=[],
+    ).to_dict()

node/protocols/activitypub/package.py

@@ -0,0 +1,271 @@
+"""fleetmesh-protocol-activitypub: ActivityPub & ActivityStreams 2.0 package.
+
+Conforms to ProtocolPackage (fleetmesh_core.wire.interfaces.ProtocolPackage).
+Mounts WebFinger (RFC 7033), Actor profiles, S2S Inbox federation,
+Outbox feeds, and Blossom unified media onto ProtocolHostRouter.
+"""
+from __future__ import annotations
+
+import json
+import urllib.parse
+from typing import Any, Mapping, Optional
+
+from fleetmesh_core.wire.interfaces import (
+    ProtocolHealth,
+    ProtocolHostRouter,
+    ProtocolIdentityAdapter,
+)
+from node.protocols.activitypub.actor import Actor, WebFingerService, ed25519_pubkey_to_pem
+from node.protocols.activitypub.federation import FederationService, StrainScoreKeeper
+from node.protocols.activitypub.media import ActivityPubMediaManager
+from node.protocols.activitypub.store import ActivityPubStore
+from node.protocols.base import BaseProtocolPackage, Ed25519IdentityAdapter
+
+__all__ = [
+    'ActivityPubIdentityAdapter',
+    'ActivityPubProtocolPackage',
+]
+
+
+class ActivityPubIdentityAdapter(Ed25519IdentityAdapter):
+    """Translates between Fleetmesh Ed25519 identities and ActivityPub Actor URIs."""
+
+    def __init__(self, actor: Actor, private_key: Any = None):
+        super().__init__(private_key=private_key)
+        self.actor = actor
+
+    def resolve_id(self, uri: str) -> Optional[str]:
+        if uri in (self.actor.acct_uri, self.actor.actor_url):
+            return self.actor.actor_url
+        return None
+
+    def verify_assertion(self, payload: bytes, signature: bytes, pubkey: str) -> bool:
+        try:
+            raw_pub = bytes.fromhex(pubkey) if len(pubkey) == 64 else pubkey.encode('utf-8')
+        except ValueError:
+            return False
+        return self._verify_ed25519_bytes(payload, signature, raw_pub)
+
+
+class ActivityPubProtocolPackage(BaseProtocolPackage):
+    """The ActivityPub & ActivityStreams 2.0 suite for Fleetmesh."""
+
+    name: str = 'activitypub'
+    version: str = '1.0.0'
+    standards: tuple[str, ...] = (
+        'activitypub',
+        'activitystreams-2.0',
+        'RFC-7033',
+        'RFC-9421',
+        'rfc7033-webfinger',
+        'draft-cavage-http-signatures',
+        'rfc9421',
+    )
+
+    def __init__(
+        self,
+        domain: str = "node.fleetmesh.local",
+        username: str = "node",
+        actor: Optional[Actor] = None,
+        store: Optional[ActivityPubStore] = None,
+        private_key: Optional[Any] = None,
+        blob_store: Optional[Any] = None,
+        strain_ledger: Optional[Any] = None,
+        keystore: Optional[Any] = None,
+    ):
+        self.domain = domain
+        self.username = username
+        self.keystore = keystore
+        self.private_key = private_key
+        self.blob_store = blob_store
+
+        # Storage
+        self.store = store or ActivityPubStore(":memory:")
+
+        # Actor Document
+        pub_pem = ""
+        if private_key is not None:
+            try:
+                pub_bytes = private_key.public_key().public_bytes_raw()
+                pub_pem = ed25519_pubkey_to_pem(pub_bytes)
+            except Exception:
+                pass
+
+        self.actor = actor or Actor(
+            domain=domain,
+            username=username,
+            public_key_pem=pub_pem,
+        )
+
+        # WebFinger Service
+        self.webfinger = WebFingerService(self.actor)
+
+        # Media Manager
+        self.media = ActivityPubMediaManager(
+            base_url=f"{self.actor.scheme}://{self.actor.domain}",
+            blob_store=blob_store,
+        )
+
+        # Federation Service
+        self.federation = FederationService(
+            store=self.store,
+            local_actor=self.actor,
+            private_key=private_key,
+            strain_score_keeper=StrainScoreKeeper(strain_ledger=strain_ledger),
+        )
+
+        self.config: Mapping[str, Any] = {}
+        self._enabled: bool = True
+        self._host: Optional[ProtocolHostRouter] = None
+
+    def configure(self, config: Mapping[str, Any]) -> None:
+        self.config = dict(config)
+        self._enabled = self.config.get('enabled', True)
+        if 'domain' in self.config:
+            self.domain = self.config['domain']
+        if 'username' in self.config:
+            self.username = self.config['username']
+
+    def identity_adapter(self, keystore: Any) -> Optional[ProtocolIdentityAdapter]:
+        return ActivityPubIdentityAdapter(actor=self.actor, private_key=self.private_key)
+
+    def mount_ingress(self, host: ProtocolHostRouter) -> None:
+        if not self._enabled:
+            return
+        self._host = host
+
+        from node.transport import ws
+
+        # 1. WebFinger RFC 7033
+        def _handle_webfinger(conn: Any, req: Any) -> bool:
+            uri = getattr(req, 'path', '')
+            parsed = urllib.parse.urlparse(uri)
+            qparams = urllib.parse.parse_qs(parsed.query)
+            status, headers, body = self.webfinger.handle_webfinger_request(qparams)
+            ws.http_response(
+                conn,
+                "200 OK" if status == 200 else f"{status} Error",
+                body,
+                headers.get('Content-Type', 'application/jrd+json'),
+            )
+            return True
+
+        host.mount_route('/.well-known/webfinger', _handle_webfinger, methods=('GET',), owner=self.name)
+
+        # 2. Shared Inbox & Personal Inbox POST
+        def _handle_inbox_post(conn: Any, req: Any) -> bool:
+            method = getattr(req, 'method', 'POST')
+            path = getattr(req, 'path', '')
+            raw_headers = getattr(req, 'headers', {}) or {}
+            headers = {
+                (k.decode('latin-1') if isinstance(k, bytes) else str(k)): (
+                    v.decode('latin-1') if isinstance(v, bytes) else str(v)
+                )
+                for k, v in raw_headers.items()
+            }
+            body = getattr(req, 'body', None)
+            if body is None:
+                body = ws.read_body(conn, req)
+            status, resp_headers, resp_body = self.federation.handle_inbox(method, path, headers, body)
+            ws.http_response(
+                conn,
+                f"{status} OK" if status in (200, 202) else f"{status} Error",
+                resp_body,
+                resp_headers.get('Content-Type', 'application/json'),
+            )
+            return True
+
+        host.mount_route('/inbox', _handle_inbox_post, methods=('POST',), owner=self.name)
+        host.mount_route(f"/users/{self.actor.username}/inbox", _handle_inbox_post, methods=('POST',), owner=self.name)
+
+        # 3. User Actor Profile, Outbox, Followers, Following
+        def _handle_user_routes(conn: Any, req: Any) -> bool:
+            path = getattr(req, 'path', '').split('?')[0].rstrip('/')
+            user_prefix = f"/users/{self.actor.username}"
+
+            if path == user_prefix:
+                # Actor JSON-LD
+                body = json.dumps(self.actor.to_jsonld(), indent=2).encode('utf-8')
+                ws.http_response(conn, "200 OK", body, "application/activity+json")
+                return True
+
+            if path == f"{user_prefix}/outbox":
+                # Outbox OrderedCollection
+                acts = self.store.list_outbox(self.actor.actor_url)
+                coll = self.store.as_ordered_collection(acts, len(acts), f"{self.actor.actor_url}/outbox")
+                body = json.dumps(coll, indent=2).encode('utf-8')
+                ws.http_response(conn, "200 OK", body, "application/activity+json")
+                return True
+
+            if path == f"{user_prefix}/followers":
+                followers = self.store.get_followers(self.actor.actor_url)
+                coll = self.store.as_ordered_collection(followers, len(followers), f"{self.actor.actor_url}/followers")
+                body = json.dumps(coll, indent=2).encode('utf-8')
+                ws.http_response(conn, "200 OK", body, "application/activity+json")
+                return True
+
+            if path == f"{user_prefix}/following":
+                following = self.store.get_following(self.actor.actor_url)
+                coll = self.store.as_ordered_collection(following, len(following), f"{self.actor.actor_url}/following")
+                body = json.dumps(coll, indent=2).encode('utf-8')
+                ws.http_response(conn, "200 OK", body, "application/activity+json")
+                return True
+
+            ws.http_response(conn, "404 Not Found", b'{"error": "not found"}', "application/json")
+            return True
+
+        host.mount_route(f"/users/{self.actor.username}", _handle_user_routes, methods=('GET',), owner=self.name)
+
+        # 4. Media Attachments
+        def _handle_media(conn: Any, req: Any) -> bool:
+            path = getattr(req, 'path', '')
+            status, headers, body = self.media.handle_media_request(path)
+            ws.http_response(
+                conn,
+                "200 OK" if status == 200 else f"{status} Error",
+                body,
+                headers.get('Content-Type', 'application/octet-stream'),
+            )
+            return True
+
+        host.mount_route('/media', _handle_media, methods=('GET',), owner=self.name)
+
+    def transport_rung(self, context: Any) -> Optional[Any]:
+        return None
+
+    def compartments(self) -> tuple[type[Any], ...]:
+        return ()
+
+    def start(self) -> None:
+        pass
+
+    def stop(self) -> None:
+        self.store.close()
+
+    def health(self) -> ProtocolHealth:
+        if not self._enabled:
+            return ProtocolHealth(
+                healthy=True,
+                status="disabled",
+                connections_active=0,
+                messages_in=0,
+                messages_out=0,
+                errors=(),
+            )
+        return ProtocolHealth(
+            healthy=True,
+            status="serving",
+            connections_active=self.store.count_followers(self.actor.actor_url),
+            messages_in=self.store.count_inbox(),
+            messages_out=self.store.count_outbox(),
+            errors=(),
+        )
+
+    def descriptor_capabilities(self) -> tuple[tuple[str, str], ...]:
+        if not self._enabled:
+            return ()
+        return (
+            ('c', 'activitypub'),
+            ('c', 'activitystreams-2.0'),
+            ('c', 'webfinger'),
+        )