fleetmesh-node 0.2.0__py3-none-any.whl

node/protocols/activitypub/store.py

@@ -0,0 +1,564 @@
+"""ActivityPub SQLite persistent store.
+
+Standard library only. Manages persistence for:
+- Local and remote actors (URI, public key, endpoints, JSON-LD profile).
+- Inbound (inbox) and outbound (outbox) activities.
+- ActivityStreams objects (Notes, Articles, Media, etc.).
+- Follower and Following relational graphs.
+- ActivityStreams OrderedCollection paging.
+"""
+from __future__ import annotations
+
+import json
+import os
+from typing import Any, Mapping, Optional, Sequence, Union
+
+from fleetmesh_core.conformance.errors import FleetmeshError
+from node.compartment.schema import Column, Index, Table
+from node.storage import SqliteStore
+from node.protocols.activitypub.actor import Actor
+from node.protocols.activitypub.models import AS_CONTEXT, Activity, Note
+
+__all__ = [
+    'ActivityPubStoreError',
+    'ActivityPubStore',
+]
+
+
+class ActivityPubStoreError(FleetmeshError):
+    """Base error for ActivityPub storage operations."""
+
+
+from node.protocols.isotime import now_iso as _now_iso  # noqa: E402
+
+
+class ActivityPubStore(SqliteStore):
+    """Storage for ActivityPub actor profiles, activities and the follow graph.
+
+    A `SqliteStore` rather than a hand-rolled connection: the base owns the
+    connection, the lock, the per-store schema version, transaction control and
+    the dialect that rewrites placeholders and upserts for another backend.
+    This store opened its own connection, ran its own PRAGMAs and declared its
+    schema as a SQL string, so it was SQLite-only and invisible to the
+    `Locator` - see docs/storage-backends.md.
+
+    The six indexes were declared `published DESC`. `Index` takes no direction,
+    and none is needed: both backends can scan an ascending index backwards, so
+    `(direction, published)` still serves `WHERE direction = ? ORDER BY
+    published DESC`.
+    """
+
+    SCHEMA = (
+        Table('ap_actors', (
+            Column('uri', 'TEXT', primary_key=True),
+            Column('type', 'TEXT', not_null=True),
+            Column('username', 'TEXT'),
+            Column('public_key_pem', 'TEXT'),
+            Column('inbox', 'TEXT'),
+            Column('outbox', 'TEXT'),
+            Column('data_json', 'TEXT', not_null=True),
+            Column('updated_at', 'TEXT', not_null=True),
+        ), indices=(
+            Index('idx_ap_actors_username', ('username',)),
+        )),
+        Table('ap_activities', (
+            Column('id', 'TEXT', primary_key=True),
+            Column('type', 'TEXT', not_null=True),
+            Column('actor', 'TEXT', not_null=True),
+            Column('target', 'TEXT'),
+            Column('published', 'TEXT', not_null=True),
+            Column('direction', 'TEXT', not_null=True),
+            Column('raw_json', 'TEXT', not_null=True),
+        ), indices=(
+            Index('idx_ap_act_dir', ('direction', 'published')),
+            Index('idx_ap_act_actor_dir', ('actor', 'direction', 'published')),
+        )),
+        Table('ap_objects', (
+            Column('id', 'TEXT', primary_key=True),
+            Column('type', 'TEXT', not_null=True),
+            Column('attributed_to', 'TEXT'),
+            Column('published', 'TEXT'),
+            Column('content', 'TEXT'),
+            Column('raw_json', 'TEXT', not_null=True),
+        ), indices=(
+            Index('idx_ap_obj_attr', ('attributed_to', 'published')),
+        )),
+        Table('ap_followers', (
+            Column('actor_uri', 'TEXT', not_null=True),
+            Column('follower_uri', 'TEXT', not_null=True),
+            Column('followed_at', 'TEXT', not_null=True),
+        ), primary_key=('actor_uri', 'follower_uri'), indices=(
+            Index('idx_ap_followers_actor', ('actor_uri',)),
+        )),
+        Table('ap_following', (
+            Column('actor_uri', 'TEXT', not_null=True),
+            Column('target_uri', 'TEXT', not_null=True),
+            Column('followed_at', 'TEXT', not_null=True),
+        ), primary_key=('actor_uri', 'target_uri'), indices=(
+            Index('idx_ap_following_actor', ('actor_uri',)),
+        )),
+    )
+
+    def __init__(self, db_path: str = ":memory:"):
+        if db_path != ":memory:":
+            dirname = os.path.dirname(db_path)
+            if dirname:
+                os.makedirs(dirname, exist_ok=True)
+        super().__init__(db_path)
+
+    def close(self) -> None:
+        super().close()
+
+    # -------------------------------------------------------------------------
+    # Actor Management
+    # -------------------------------------------------------------------------
+
+    def upsert_actor(self, actor: Union[Actor, Mapping[str, Any]]) -> None:
+        """Persist or update an Actor document."""
+        if isinstance(actor, Actor):
+            doc = actor.to_jsonld()
+        elif isinstance(actor, (dict, Mapping)):
+            doc = dict(actor)
+        else:
+            raise ActivityPubStoreError("actor must be an Actor instance or dict")
+
+        uri = doc.get('id')
+        if not uri or not isinstance(uri, str):
+            raise ActivityPubStoreError("actor document missing 'id' URI")
+
+        act_type = doc.get('type', 'Person')
+        username = doc.get('preferredUsername')
+        inbox = doc.get('inbox')
+        outbox = doc.get('outbox')
+
+        pk_pem = None
+        pk_obj = doc.get('publicKey')
+        if isinstance(pk_obj, dict):
+            pk_pem = pk_obj.get('publicKeyPem')
+
+        data_json = json.dumps(doc, sort_keys=True)
+        updated_at = _now_iso()
+
+        with self._lock:
+            with self.transaction() as _cur:
+                _cur.execute(
+                    """
+                    INSERT INTO ap_actors (uri, type, username, public_key_pem, inbox, outbox, data_json, updated_at)
+                    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+                    ON CONFLICT(uri) DO UPDATE SET
+                        type=excluded.type,
+                        username=excluded.username,
+                        public_key_pem=excluded.public_key_pem,
+                        inbox=excluded.inbox,
+                        outbox=excluded.outbox,
+                        data_json=excluded.data_json,
+                        updated_at=excluded.updated_at
+                    """,
+                    (uri, act_type, username, pk_pem, inbox, outbox, data_json, updated_at),
+                )
+
+    def get_actor(self, uri: str) -> Optional[Mapping[str, Any]]:
+        """Retrieve an Actor document by its URI."""
+        with self._lock:
+            row = self._one(
+                "SELECT data_json FROM ap_actors WHERE uri = ?",
+                (uri,),
+            )
+            if not row:
+                return None
+            return json.loads(row[0])
+
+    def get_actor_by_username(self, username: str) -> Optional[Mapping[str, Any]]:
+        """Retrieve an Actor document by preferredUsername."""
+        with self._lock:
+            row = self._one(
+                "SELECT data_json FROM ap_actors WHERE LOWER(username) = LOWER(?)",
+                (username,),
+            )
+            if not row:
+                return None
+            return json.loads(row[0])
+
+    def get_actor_public_key_pem(self, uri: str) -> Optional[str]:
+        """Directly query an actor's public key PEM string."""
+        with self._lock:
+            row = self._one(
+                "SELECT public_key_pem FROM ap_actors WHERE uri = ?",
+                (uri,),
+            )
+            if not row or not row[0]:
+                return None
+            return row[0]
+
+    # -------------------------------------------------------------------------
+    # Object Management (Notes, Articles, etc.)
+    # -------------------------------------------------------------------------
+
+    def save_object(self, obj: Union[Note, Mapping[str, Any]]) -> None:
+        """Persist or update an ActivityStreams object."""
+        if isinstance(obj, Note):
+            doc = obj.to_dict()
+        elif isinstance(obj, (dict, Mapping)):
+            doc = dict(obj)
+        else:
+            raise ActivityPubStoreError("object must be a Note or dict")
+
+        obj_id = doc.get('id')
+        if not obj_id or not isinstance(obj_id, str):
+            raise ActivityPubStoreError("object missing 'id'")
+
+        obj_type = doc.get('type', 'Object')
+        attributed_to = doc.get('attributedTo')
+        published = doc.get('published') or _now_iso()
+        content = doc.get('content')
+        raw_json = json.dumps(doc, sort_keys=True)
+
+        with self._lock:
+            with self.transaction() as _cur:
+                _cur.execute(
+                    """
+                    INSERT INTO ap_objects (id, type, attributed_to, published, content, raw_json)
+                    VALUES (?, ?, ?, ?, ?, ?)
+                    ON CONFLICT(id) DO UPDATE SET
+                        type=excluded.type,
+                        attributed_to=excluded.attributed_to,
+                        published=excluded.published,
+                        content=excluded.content,
+                        raw_json=excluded.raw_json
+                    """,
+                    (obj_id, obj_type, attributed_to, published, content, raw_json),
+                )
+
+    def get_object(self, id: str) -> Optional[Mapping[str, Any]]:
+        """Retrieve an ActivityStreams object by ID."""
+        with self._lock:
+            row = self._one(
+                "SELECT raw_json FROM ap_objects WHERE id = ?",
+                (id,),
+            )
+            if not row:
+                return None
+            return json.loads(row[0])
+
+    # -------------------------------------------------------------------------
+    # Activity Management (Inbox / Outbox)
+    # -------------------------------------------------------------------------
+
+    def record_activity(
+        self,
+        activity: Union[Activity, Mapping[str, Any]],
+        direction: str,
+    ) -> None:
+        """Record an inbound ('inbox') or outbound ('outbox') activity.
+
+        If the activity contains an embedded object dictionary, it will automatically
+        be persisted to the objects table.
+        """
+        if direction not in ('inbox', 'outbox'):
+            raise ActivityPubStoreError("direction must be 'inbox' or 'outbox'")
+
+        if isinstance(activity, Activity):
+            doc = activity.to_dict()
+        elif isinstance(activity, dict):
+            doc = dict(activity)
+        else:
+            raise ActivityPubStoreError("activity must be an Activity or dict")
+
+        act_id = doc.get('id')
+        if not act_id or not isinstance(act_id, str):
+            raise ActivityPubStoreError("activity missing 'id'")
+
+        act_type = doc.get('type')
+        if not act_type or not isinstance(act_type, str):
+            raise ActivityPubStoreError("activity missing 'type'")
+
+        actor = doc.get('actor')
+        if not actor or not isinstance(actor, str):
+            raise ActivityPubStoreError("activity missing 'actor'")
+
+        target = None
+        obj = doc.get('object')
+        if isinstance(obj, dict):
+            target = obj.get('id')
+            # Auto-save embedded object
+            try:
+                self.save_object(obj)
+            except Exception:
+                pass
+        elif isinstance(obj, str):
+            target = obj
+
+        published = doc.get('published') or _now_iso()
+        raw_json = json.dumps(doc, sort_keys=True)
+
+        with self._lock:
+            with self.transaction() as _cur:
+                _cur.execute(
+                    """
+                    INSERT INTO ap_activities (id, type, actor, target, published, direction, raw_json)
+                    VALUES (?, ?, ?, ?, ?, ?, ?)
+                    ON CONFLICT(id) DO UPDATE SET
+                        type=excluded.type,
+                        actor=excluded.actor,
+                        target=excluded.target,
+                        published=excluded.published,
+                        direction=excluded.direction,
+                        raw_json=excluded.raw_json
+                    """,
+                    (act_id, act_type, actor, target, published, direction, raw_json),
+                )
+
+    def get_activity(self, id: str) -> Optional[Mapping[str, Any]]:
+        """Retrieve an activity by ID."""
+        with self._lock:
+            row = self._one(
+                "SELECT raw_json FROM ap_activities WHERE id = ?",
+                (id,),
+            )
+            if not row:
+                return None
+            return json.loads(row[0])
+
+    def list_inbox(
+        self,
+        actor_uri: Optional[str] = None,
+        limit: int = 50,
+        offset: int = 0,
+    ) -> list[Mapping[str, Any]]:
+        """List incoming activities, optionally filtered by actor."""
+        with self._lock:
+            if actor_uri:
+                rows = self._all(
+                    """
+                    SELECT raw_json FROM ap_activities
+                    WHERE direction = 'inbox' AND actor = ?
+                    ORDER BY published DESC, id DESC
+                    LIMIT ? OFFSET ?
+                    """,
+                    (actor_uri, limit, offset),
+                )
+            else:
+                rows = self._all(
+                    """
+                    SELECT raw_json FROM ap_activities
+                    WHERE direction = 'inbox'
+                    ORDER BY published DESC, id DESC
+                    LIMIT ? OFFSET ?
+                    """,
+                    (limit, offset),
+                )
+            return [json.loads(r[0]) for r in rows]
+
+    def list_outbox(
+        self,
+        actor_uri: Optional[str] = None,
+        limit: int = 50,
+        offset: int = 0,
+    ) -> list[Mapping[str, Any]]:
+        """List outgoing activities, optionally filtered by actor."""
+        with self._lock:
+            if actor_uri:
+                rows = self._all(
+                    """
+                    SELECT raw_json FROM ap_activities
+                    WHERE direction = 'outbox' AND actor = ?
+                    ORDER BY published DESC, id DESC
+                    LIMIT ? OFFSET ?
+                    """,
+                    (actor_uri, limit, offset),
+                )
+            else:
+                rows = self._all(
+                    """
+                    SELECT raw_json FROM ap_activities
+                    WHERE direction = 'outbox'
+                    ORDER BY published DESC, id DESC
+                    LIMIT ? OFFSET ?
+                    """,
+                    (limit, offset),
+                )
+            return [json.loads(r[0]) for r in rows]
+
+    def count_inbox(self, actor_uri: Optional[str] = None) -> int:
+        """Count incoming activities."""
+        with self._lock:
+            if actor_uri:
+                row = self._one(
+                    "SELECT COUNT(*) FROM ap_activities WHERE direction = 'inbox' AND actor = ?",
+                    (actor_uri,),
+                )
+            else:
+                row = self._one(
+                    "SELECT COUNT(*) FROM ap_activities WHERE direction = 'inbox'"
+                )
+            return int(row[0]) if row else 0
+
+    def count_outbox(self, actor_uri: Optional[str] = None) -> int:
+        """Count outgoing activities."""
+        with self._lock:
+            if actor_uri:
+                row = self._one(
+                    "SELECT COUNT(*) FROM ap_activities WHERE direction = 'outbox' AND actor = ?",
+                    (actor_uri,),
+                )
+            else:
+                row = self._one(
+                    "SELECT COUNT(*) FROM ap_activities WHERE direction = 'outbox'"
+                )
+            return int(row[0]) if row else 0
+
+    # -------------------------------------------------------------------------
+    # Social Graph (Followers & Following)
+    # -------------------------------------------------------------------------
+
+    def add_follower(
+        self,
+        actor_uri: str,
+        follower_uri: str,
+        followed_at: Optional[str] = None,
+    ) -> None:
+        """Record a follower for an actor."""
+        ts = followed_at or _now_iso()
+        with self._lock:
+            with self.transaction() as _cur:
+                _cur.execute(
+                    """
+                    INSERT INTO ap_followers (actor_uri, follower_uri, followed_at)
+                    VALUES (?, ?, ?)
+                    ON CONFLICT(actor_uri, follower_uri) DO NOTHING
+                    """,
+                    (actor_uri, follower_uri, ts),
+                )
+
+    def remove_follower(self, actor_uri: str, follower_uri: str) -> None:
+        """Remove a follower relationship."""
+        with self._lock:
+            with self.transaction() as _cur:
+                _cur.execute(
+                    "DELETE FROM ap_followers WHERE actor_uri = ? AND follower_uri = ?",
+                    (actor_uri, follower_uri),
+                )
+
+    def get_followers(
+        self,
+        actor_uri: str,
+        limit: int = 100,
+        offset: int = 0,
+    ) -> list[str]:
+        """List follower URIs for an actor."""
+        with self._lock:
+            rows = self._all(
+                """
+                SELECT follower_uri FROM ap_followers
+                WHERE actor_uri = ?
+                ORDER BY followed_at DESC
+                LIMIT ? OFFSET ?
+                """,
+                (actor_uri, limit, offset),
+            )
+            return [r[0] for r in rows]
+
+    def count_followers(self, actor_uri: str) -> int:
+        """Return the total number of followers for an actor."""
+        with self._lock:
+            row = self._one(
+                "SELECT COUNT(*) FROM ap_followers WHERE actor_uri = ?",
+                (actor_uri,),
+            )
+            return int(row[0]) if row else 0
+
+    def add_following(
+        self,
+        actor_uri: str,
+        target_uri: str,
+        followed_at: Optional[str] = None,
+    ) -> None:
+        """Record an actor following a remote target."""
+        ts = followed_at or _now_iso()
+        with self._lock:
+            with self.transaction() as _cur:
+                _cur.execute(
+                    """
+                    INSERT INTO ap_following (actor_uri, target_uri, followed_at)
+                    VALUES (?, ?, ?)
+                    ON CONFLICT(actor_uri, target_uri) DO NOTHING
+                    """,
+                    (actor_uri, target_uri, ts),
+                )
+
+    def remove_following(self, actor_uri: str, target_uri: str) -> None:
+        """Remove a following relationship."""
+        with self._lock:
+            with self.transaction() as _cur:
+                _cur.execute(
+                    "DELETE FROM ap_following WHERE actor_uri = ? AND target_uri = ?",
+                    (actor_uri, target_uri),
+                )
+
+    def get_following(
+        self,
+        actor_uri: str,
+        limit: int = 100,
+        offset: int = 0,
+    ) -> list[str]:
+        """List target URIs that an actor follows."""
+        with self._lock:
+            rows = self._all(
+                """
+                SELECT target_uri FROM ap_following
+                WHERE actor_uri = ?
+                ORDER BY followed_at DESC
+                LIMIT ? OFFSET ?
+                """,
+                (actor_uri, limit, offset),
+            )
+            return [r[0] for r in rows]
+
+    def count_following(self, actor_uri: str) -> int:
+        """Return the total number of actors that an actor follows."""
+        with self._lock:
+            row = self._one(
+                "SELECT COUNT(*) FROM ap_following WHERE actor_uri = ?",
+                (actor_uri,),
+            )
+            return int(row[0]) if row else 0
+
+    # -------------------------------------------------------------------------
+    # OrderedCollection Serialization
+    # -------------------------------------------------------------------------
+
+    @staticmethod
+    def as_ordered_collection(
+        items: Sequence[Any],
+        total_items: int,
+        id_url: str,
+        page: Optional[int] = None,
+        page_size: int = 50,
+    ) -> Mapping[str, Any]:
+        """Format items as an ActivityStreams 2.0 OrderedCollection or OrderedCollectionPage."""
+        if page is None:
+            doc = {
+                "@context": AS_CONTEXT,
+                "id": id_url,
+                "type": "OrderedCollection",
+                "totalItems": total_items,
+                "first": f"{id_url}?page=1",
+            }
+            if total_items > 0:
+                last_page = max(1, (total_items + page_size - 1) // page_size)
+                doc["last"] = f"{id_url}?page={last_page}"
+            return doc
+
+        page_doc = {
+            "@context": AS_CONTEXT,
+            "id": f"{id_url}?page={page}",
+            "type": "OrderedCollectionPage",
+            "partOf": id_url,
+            "totalItems": total_items,
+            "orderedItems": list(items),
+        }
+        if page > 1:
+            page_doc["prev"] = f"{id_url}?page={page - 1}"
+        if (page * page_size) < total_items:
+            page_doc["next"] = f"{id_url}?page={page + 1}"
+        return page_doc

node/protocols/arcade/__init__.py

@@ -0,0 +1,26 @@
+"""FleetMesh Node Arcade Protocol Package (`node.protocols.arcade`)."""
+from __future__ import annotations
+
+# The stores and route handlers live in the fleetmesh-protocols package
+# (fleetmesh_protocols.arcade); this package re-exports them so node code and
+# the protocol router keep their import paths.
+
+from fleetmesh_protocols.arcade.routes import HttpResult, JSON_CT, handle_arcade_http
+from fleetmesh_protocols.arcade.store import (
+    ArcadeError,
+    MAX_DESKTOP_JSON_BYTES,
+    MAX_RECORD_JSON_BYTES,
+    TOMBSTONE_TTL_SEC,
+    StandaloneArcadeStore,
+)
+
+__all__ = [
+    "ArcadeError",
+    "MAX_DESKTOP_JSON_BYTES",
+    "MAX_RECORD_JSON_BYTES",
+    "TOMBSTONE_TTL_SEC",
+    "StandaloneArcadeStore",
+    "HttpResult",
+    "JSON_CT",
+    "handle_arcade_http",
+]

node/protocols/atproto/__init__.py

@@ -0,0 +1,13 @@
+"""AT Protocol (atproto) package for Fleetmesh.
+
+Supports:
+- Repositories, MST storage, and CAR export/import.
+- XRPC HTTP server and Firehose subscribeRepos WebSocket stream.
+- Cross-protocol mapping between Nostr, ActivityPub, and ATProto records.
+"""
+from __future__ import annotations
+
+from .package import AtprotoProtocolPackage
+from .repo import Repo
+
+__all__ = ['AtprotoProtocolPackage', 'Repo']