fleetmesh-node 0.2.0__py3-none-any.whl

node/protocols/textile/transducers.py

@@ -0,0 +1,259 @@
+"""Python Pluggable Protocol Transducers & Router (`node.protocols.textile.transducers`).
+
+Server-side twin of `@fleetmesh/protocols` (`MeshProtocolRouter` & `ProtocolTransducer`),
+projecting and ingesting FleetMesh Textile primitives (`fiber`, `strand`, `spool`, `fabric`,
+`quilt`, `suit`, `fit`, `tombstone`) across `nostr`, `w3c`, `activitypub`, `atproto`,
+`p2panda`, `ssb`, `didcomm`, and `grasp`.
+"""
+from __future__ import annotations
+
+import time
+from typing import Any, Dict, Iterable, Mapping, MutableMapping, Optional
+
+from fleetmesh_core.identity import identity
+from fleetmesh_core.textile.bip340 import schnorr_sign, xonly_pubkey
+from fleetmesh_core.textile.canonical import canonical_json
+from fleetmesh_core.textile.signing import (
+    FLEETMESH_STATEMENT_DOMAIN,
+    nostr_event_id,
+    sign_statement,
+    verify_envelope,
+)
+
+TEXTILE_CONTEXT = identity.FLEETMESH + 'ns/textile/v1'
+LOCAL_AP_DOMAIN = 'fleetmesh.local'
+
+DEFAULT_FALLBACK_SK = '0101010101010101010101010101010101010101010101010101010101010101'
+
+PROTOCOL_FAMILIES = ('nostr', 'w3c', 'activitypub', 'atproto', 'p2panda', 'ssb', 'didcomm', 'grasp')
+
+
+class PythonProtocolRouter:
+    """Projects and ingests Textile primitive manifests across all 8 FleetMesh protocol families."""
+
+    def project(
+        self,
+        family: str,
+        layer: str,
+        primitive_id: str,
+        bao_root: str,
+        manifest: Mapping[str, Any],
+        *,
+        author: Optional[Mapping[str, Any]] = None,
+        visibility: str = 'public',
+        sk_hex: str = DEFAULT_FALLBACK_SK,
+        timestamp_sec: Optional[int] = None,
+    ) -> MutableMapping[str, Any]:
+        fam = family.strip().lower()
+        if fam not in PROTOCOL_FAMILIES:
+            raise ValueError(f"Unsupported protocol family: {family}")
+        ts = int(timestamp_sec or time.time())
+        pubkey = xonly_pubkey(sk_hex)
+        resolved_author = dict(author or {'identity_id': pubkey[:16], 'did': f'did:nostr:{pubkey}'})
+        sig_env = sign_statement(
+            {
+                'domain': FLEETMESH_STATEMENT_DOMAIN,
+                'kind': f'{layer}_root' if layer != 'tombstone' else 'tombstone',
+                'root': bao_root,
+                'signer_did': f'did:nostr:{pubkey}',
+                'signed_at': ts,
+            },
+            sk_hex,
+        )
+
+        if fam == 'nostr':
+            content = canonical_json({
+                'v': 1,
+                'domain': FLEETMESH_STATEMENT_DOMAIN,
+                'layer': layer,
+                'primitive_id': primitive_id,
+                'bao_root': bao_root,
+                'author': resolved_author,
+                'visibility': visibility,
+                'manifest': dict(manifest),
+            })
+            unsigned_ev = {
+                'pubkey': pubkey,
+                'created_at': ts,
+                'kind': 30899,
+                'tags': [['d', f'{layer}:{primitive_id}'], ['bao', bao_root], ['layer', layer]],
+                'content': content,
+            }
+            ev_id = nostr_event_id(unsigned_ev)
+            ev_sig = schnorr_sign(bytes.fromhex(ev_id), sk_hex)
+            wire: MutableMapping[str, Any] = {
+                'protocol': 'nostr',
+                'event': {**unsigned_ev, 'id': ev_id, 'sig': ev_sig},
+                'layer': layer,
+                'primitive_id': primitive_id,
+                'bao_root': bao_root,
+                'author': resolved_author,
+                'visibility': visibility,
+                'manifest': dict(manifest),
+                'signature': sig_env,
+            }
+        elif fam == 'w3c':
+            wire = {
+                '@context': ['https://www.w3.org/ns/credentials/v2', TEXTILE_CONTEXT],
+                'id': f'urn:uuid:vc-{layer}-{bao_root[:32]}',
+                'type': ['VerifiableCredential', f'FleetMeshTextile{layer.capitalize()}Credential'],
+                'issuer': {'id': f'did:nostr:{pubkey}'},
+                'credentialSubject': {
+                    'id': f'mesh://{layer}/{bao_root}',
+                    'layer': layer,
+                    'primitive_id': primitive_id,
+                    'bao_root': bao_root,
+                    'author': resolved_author,
+                    'visibility': visibility,
+                    'manifest': dict(manifest),
+                },
+                'proof': {'envelope': sig_env},
+            }
+        elif fam == 'activitypub':
+            wire = {
+                '@context': ['https://www.w3.org/ns/activitystreams', TEXTILE_CONTEXT],
+                'id': f'https://{LOCAL_AP_DOMAIN}/ap/activities/{layer}/{bao_root}',
+                'type': 'Delete' if layer == 'tombstone' else 'Create',
+                'actor': resolved_author.get('did', f'did:nostr:{pubkey}'),
+                'object': {
+                    'id': f'mesh://{layer}/{bao_root}',
+                    'fleetmesh:layer': layer,
+                    'fleetmesh:primitiveId': primitive_id,
+                    'fleetmesh:baoRoot': bao_root,
+                    'fleetmesh:author': resolved_author,
+                    'fleetmesh:visibility': visibility,
+                    'fleetmesh:manifest': dict(manifest),
+                    'fleetmesh:signature': sig_env,
+                },
+            }
+        elif fam == 'atproto':
+            collection = f'mesh.fleetmesh.textile.{layer}'
+            uri = f"at://{resolved_author.get('did', f'did:nostr:{pubkey}')}/{collection}/{bao_root[:13]}"
+            wire = {
+                'uri': uri,
+                'collection': collection,
+                'value': {
+                    '$type': collection,
+                    'layer': layer,
+                    'primitiveId': primitive_id,
+                    'baoRoot': bao_root,
+                    'author': resolved_author,
+                    'visibility': visibility,
+                    'manifest': dict(manifest),
+                },
+                'commit': {'signature': sig_env},
+            }
+        else:
+            wire = {
+                'protocol': fam,
+                'layer': layer,
+                'primitive_id': primitive_id,
+                'bao_root': bao_root,
+                'author': resolved_author,
+                'visibility': visibility,
+                'manifest': dict(manifest),
+                'signature': sig_env,
+            }
+
+        return {
+            'protocol': fam,
+            'layer': layer,
+            'primitive_id': primitive_id,
+            'bao_root': bao_root,
+            'wire_envelope': wire,
+            'projected_at': ts,
+        }
+
+    def project_all(
+        self,
+        layer: str,
+        primitive_id: str,
+        bao_root: str,
+        manifest: Mapping[str, Any],
+        *,
+        families: Optional[Iterable[str]] = None,
+        author: Optional[Mapping[str, Any]] = None,
+        visibility: str = 'public',
+        sk_hex: str = DEFAULT_FALLBACK_SK,
+    ) -> Dict[str, MutableMapping[str, Any]]:
+        targets = list(families) if families is not None else list(PROTOCOL_FAMILIES)
+        return {
+            fam: self.project(
+                fam,
+                layer,
+                primitive_id,
+                bao_root,
+                manifest,
+                author=author,
+                visibility=visibility,
+                sk_hex=sk_hex,
+            )
+            for fam in targets
+        }
+
+    def ingest(self, wire: Any) -> Optional[MutableMapping[str, Any]]:
+        if not isinstance(wire, Mapping):
+            return None
+        if 'credentialSubject' in wire and 'proof' in wire:
+            subj = wire['credentialSubject']
+            sig = wire['proof'].get('envelope')
+            root = str(subj.get('bao_root') or '')
+            if not verify_envelope(sig, root=root):
+                return None
+            return {
+                'protocol': 'w3c',
+                'layer': subj.get('layer'),
+                'primitive_id': subj.get('primitive_id'),
+                'bao_root': root,
+                'manifest': subj.get('manifest'),
+                'verified': True,
+            }
+        if 'object' in wire and isinstance(wire.get('object'), Mapping) and 'fleetmesh:baoRoot' in wire['object']:
+            obj = wire['object']
+            root = str(obj.get('fleetmesh:baoRoot') or '')
+            sig = obj.get('fleetmesh:signature')
+            if not verify_envelope(sig, root=root):
+                return None
+            return {
+                'protocol': 'activitypub',
+                'layer': obj.get('fleetmesh:layer'),
+                'primitive_id': obj.get('fleetmesh:primitiveId'),
+                'bao_root': root,
+                'manifest': obj.get('fleetmesh:manifest'),
+                'verified': True,
+            }
+        if isinstance(wire.get('uri'), str) and wire['uri'].startswith('at://'):
+            val = wire.get('value') or {}
+            root = str(val.get('baoRoot') or '')
+            sig = (wire.get('commit') or {}).get('signature')
+            if not verify_envelope(sig, root=root):
+                return None
+            return {
+                'protocol': 'atproto',
+                'layer': val.get('layer'),
+                'primitive_id': val.get('primitiveId'),
+                'bao_root': root,
+                'manifest': val.get('manifest'),
+                'verified': True,
+            }
+        root = str(wire.get('bao_root') or '')
+        sig = wire.get('signature')
+        if root and verify_envelope(sig, root=root):
+            return {
+                'protocol': str(wire.get('protocol') or 'nostr'),
+                'layer': wire.get('layer'),
+                'primitive_id': wire.get('primitive_id'),
+                'bao_root': root,
+                'manifest': wire.get('manifest'),
+                'verified': True,
+            }
+        return None
+
+
+default_python_protocol_router = PythonProtocolRouter()
+
+__all__ = [
+    "PROTOCOL_FAMILIES",
+    "PythonProtocolRouter",
+    "default_python_protocol_router",
+]

node/release.py

@@ -0,0 +1,119 @@
+"""What a running node knows about itself: name, semver, commit, protocol.
+
+Before this the node had a protocol version (`fleetmesh/0.1-draft@<digest>`) and
+nothing else - "fleetmesh is not installed as a package; the node runs from
+the checkout" (pyproject.toml). An update check needs a left-hand side:
+"0.9.4 is available" means nothing until the node can say "I run 0.9.3".
+This module is that left-hand side, and it imports nothing heavy on purpose:
+`node.config` reads it, and the config layer must stay importable on a bare
+host (see test_config_contract).
+
+  node/RELEASE   one line, the semver. Edited by a reviewed release commit,
+                 the same way every other pin in this tree moves.
+  node/COMMIT    written by scripts/release.sh into the packaged tree; a
+                 checkout has .git instead and asks it.
+  node/PROTOCOL  the schema digest, stamped likewise; a checkout reads
+                 schema/DIGEST.
+  node/PUBLISHER the pubkey that signed the release this tree came from,
+                 stamped likewise; a checkout reads it from the package
+                 manifest. "The key that made me" - the updates compartment
+                 listens to it unless the operator writes another.
+
+`source` says which of those this is. A checkout is a developer's tree, not
+an installed release, and nothing that installs releases should touch it.
+"""
+from __future__ import annotations
+
+import dataclasses
+import os
+import re
+import subprocess
+from typing import Optional
+
+_HERE = os.path.dirname(os.path.abspath(__file__))
+_ROOT = os.path.dirname(_HERE)
+NAME: str = 'fleetmesh-node'
+
+# semver grammar and order are a protocol matter (operations plane), so they
+# live in the reference. fleetmesh_core.peering.release is stdlib-only, which keeps this module
+# importable on a bare host (test_config_contract).
+from fleetmesh_core.peering.release import NAME as _REF_NAME, SEMVER, classify, compare, parse_semver  # noqa: E402
+
+__all__ = ['NAME', 'SEMVER', 'Release', 'classify', 'compare', 'parse_semver', 'running']
+
+assert NAME == _REF_NAME, 'node.release.NAME drifted from fleetmesh_core.peering.release.NAME'
+
+
+@dataclasses.dataclass(frozen=True)
+class Release:
+    name: str
+    version: str
+    protocol: str                 # the schema digest this tree speaks
+    commit: Optional[str] = None
+    source: str = 'checkout'      # 'release' | 'checkout'
+    publisher: Optional[str] = None   # who signed the release this tree came from
+
+    def as_dict(self) -> dict[str, Optional[str]]:
+        return {'name': self.name, 'version': self.version, 'protocol': self.protocol,
+                'commit': self.commit, 'source': self.source, 'publisher': self.publisher}
+
+
+def _read(path: str) -> Optional[str]:
+    try:
+        with open(path, encoding='utf-8') as f:
+            v = f.read().strip()
+        return v or None
+    except OSError:
+        return None
+
+
+def _git_commit(root: str) -> Optional[str]:
+    if not os.path.isdir(os.path.join(root, '.git')):
+        return None
+    try:
+        out = subprocess.run(['git', '-C', root, 'rev-parse', 'HEAD'], capture_output=True, text=True, timeout=5)
+    except (OSError, subprocess.SubprocessError):
+        return None
+    sha = out.stdout.strip()
+    return sha if out.returncode == 0 and re.fullmatch(r'[0-9a-f]{40}', sha) else None
+
+
+def _digest() -> str:
+    try:
+        from fleetmesh_core.wire import schema_files
+        return schema_files.digest()
+    except Exception:
+        return ''
+
+
+def running(root: str = _ROOT) -> Release:
+    """The release this tree is. Never raises: a tree with no RELEASE file
+    is version 0.0.0 from a checkout, which the update check treats as
+    "not a release" rather than "behind"."""
+    node_dir = os.path.join(root, 'node')
+    version = _read(os.path.join(node_dir, 'RELEASE')) or '0.0.0'
+    if parse_semver(version) is None:
+        version = '0.0.0'
+    # a release tree has node/PROTOCOL stamped from the digest it was built
+    # with; a checkout speaks whatever fleetmesh_schema it imports. A tree with
+    # neither (a bare directory) speaks nothing - that is what '' means.
+    protocol = _read(os.path.join(node_dir, 'PROTOCOL')) or (_digest() if os.path.isdir(node_dir) else '')
+    stamped = _read(os.path.join(node_dir, 'COMMIT'))
+    publisher = _publisher(root, node_dir)
+    if stamped and not os.path.isdir(os.path.join(root, '.git')):
+        return Release(NAME, version, protocol, commit=stamped, source='release', publisher=publisher)
+    return Release(NAME, version, protocol, commit=_git_commit(root) or stamped, source='checkout', publisher=publisher)
+
+
+def _publisher(root: str, node_dir: str) -> Optional[str]:
+    """node/PUBLISHER in a packaged tree; the package manifest in a checkout."""
+    v = _read(os.path.join(node_dir, 'PUBLISHER'))
+    if v is None:
+        try:
+            import json
+            with open(os.path.join(root, 'packages', NAME, '.npack', 'manifest.json'), encoding='utf-8') as f:
+                v = json.load(f).get('publisher')
+        except (OSError, ValueError):
+            v = None
+    v = str(v).strip().lower() if v else None
+    return v if v and re.fullmatch(r'[0-9a-f]{64}', v) else None

node/storage/__init__.py

@@ -0,0 +1,88 @@
+"""Node state storage: one base, one dialect per backend.
+
+    BaseStore        the backend-independent half (node/storage/base.py)
+    SqliteDialect    the default, and the only backend that needs no operator
+    PostgresDialect  the option, behind psycopg (node/storage/postgres.py)
+    Dialect          what a second backend has to implement
+    Locator          which backend a node runs on, decided once from config
+
+The design and the census it rests on are docs/storage-backends.md; the order
+of work is docs/storage-plan-2026-10-08.md. All stores build on `SqliteStore`
+or `BaseStore`.
+"""
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from .adapter import (DatabaseAdapter, PostgresAdapter, PsqlAdapter,
+                      SqliteAdapter, adapter_from_locator, create_adapter)
+from .base import BaseStore, LEASE_SECONDS, StoreLease, StoreOwnedError
+from .dialect import Dialect, SqliteDialect, ensure_incremental_vacuum
+from .locator import Locator, StorageBackend, redact
+from .postgres import PostgresDialect
+
+
+class BaseSqliteStore(BaseStore):
+    """BaseStore bound to SQLite. The primary store base for SQLite-backed node stores."""
+
+    def __init__(self, path: str = ':memory:', timeout: float = 5.0,
+                 dialect: Optional[object] = None, **kw: Any) -> None:
+        super().__init__(path, timeout, dialect or SqliteDialect(), **kw)  # type: ignore[arg-type]
+
+
+# Canonical name for SQLite store base
+SqliteStore = BaseSqliteStore
+
+
+
+# Every backend the node knows how to open. PostgresDialect is listed here
+# whether or not its driver is installed: constructing one imports nothing,
+# and its `errors()` answers with an empty tuple when psycopg is missing, so
+# store_errors() below stays correct on a host that only has SQLite.
+DIALECTS: tuple[type, ...] = (SqliteDialect, PostgresDialect)
+
+
+def store_errors() -> tuple[type[BaseException], ...]:
+    """Every error type a configured backend's driver raises.
+
+    For `except store_errors():` where the old code said `except
+    sqlite3.Error:` - a narrow catch that stays narrow, and stays correct when
+    a second driver with its own exception hierarchy is added. Catching
+    `Exception` instead would be portable and would also swallow bugs.
+    """
+    out: tuple[type[BaseException], ...] = ()
+    for d in DIALECTS:
+        out = out + tuple(d().errors())
+    return out
+
+__all__ = ['BaseSqliteStore', 'SqliteStore', 'BaseStore', 'StoreOwnedError', 'StoreLease', 'LEASE_SECONDS',
+           'Dialect', 'SqliteDialect', 'PostgresDialect', 'Locator', 'StorageBackend', 'redact',
+           'ensure_incremental_vacuum', 'DIALECTS', 'store_errors',
+           'DatabaseAdapter', 'SqliteAdapter', 'PsqlAdapter', 'PostgresAdapter',
+           'create_adapter', 'adapter_from_locator', 'AccountStore', 'GrantStore',
+           'ProjectedNodeStore', 'TableProjector', 'CausalProjector',
+           'ShardCoverageManager', 'PeerStandingStore']
+
+
+def __getattr__(name: str) -> Any:
+    if name == 'AccountStore':
+        from .accounts import AccountStore
+        return AccountStore
+    if name == 'GrantStore':
+        from .grants import GrantStore
+        return GrantStore
+    if name in ('ProjectedNodeStore', 'TableProjector', 'CausalProjector'):
+        from . import projected as _proj
+        return getattr(_proj, name)
+    if name == 'ShardCoverageManager':
+        from .sharding import ShardCoverageManager
+        return ShardCoverageManager
+    if name == 'PeerStandingStore':
+        from .standing import PeerStandingStore
+        return PeerStandingStore
+    if name in ('accounts', 'grants', 'projected', 'sharding', 'standing'):
+        import importlib
+        return importlib.import_module(f'.{name}', __package__)
+    raise AttributeError(f"module '{__name__}' has no attribute '{name}'")
+
+