relayfabric-sdk 0.4.0__tar.gz

relayfabric_sdk-0.4.0/PKG-INFO

@@ -0,0 +1,25 @@
+Metadata-Version: 2.4
+Name: relayfabric-sdk
+Version: 0.4.0
+Summary: RelayFabric Python plugin SDK: Plugin Protocol v1 frame codec, main-loop scaffold, bridge plumbing, sent-cache, and test harness.
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://docs.relayfabric.org
+Project-URL: Repository, https://github.com/RelayFabric/RelayFabric
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: cbor2
+
+# relayfabric-sdk
+
+The Python side of RelayFabric's Plugin Protocol v1: the CBOR frame codec
+(`relayfabric_sdk.ipc`, golden-locked byte-for-byte against the Rust
+implementation), the `run_plugin` main-loop scaffold, shared Bridge plumbing
+(`relayfabric_sdk.bridge`), the sent-message loop-guard cache, and the
+`FakeSock` test harness.
+
+A complete plugin is ~30 lines — see `examples/echo_plugin.py`. Prove any
+plugin against the daemon-side contract with:
+
+    switchyardctl plugin test "python my_plugin.py"
+
+Docs: https://docs.relayfabric.org/plugin-authors/

relayfabric_sdk-0.4.0/README.md

@@ -0,0 +1,14 @@
+# relayfabric-sdk
+
+The Python side of RelayFabric's Plugin Protocol v1: the CBOR frame codec
+(`relayfabric_sdk.ipc`, golden-locked byte-for-byte against the Rust
+implementation), the `run_plugin` main-loop scaffold, shared Bridge plumbing
+(`relayfabric_sdk.bridge`), the sent-message loop-guard cache, and the
+`FakeSock` test harness.
+
+A complete plugin is ~30 lines — see `examples/echo_plugin.py`. Prove any
+plugin against the daemon-side contract with:
+
+    switchyardctl plugin test "python my_plugin.py"
+
+Docs: https://docs.relayfabric.org/plugin-authors/

relayfabric_sdk-0.4.0/pyproject.toml

@@ -0,0 +1,22 @@
+[project]
+name = "relayfabric-sdk"
+version = "0.4.0"
+description = "RelayFabric Python plugin SDK: Plugin Protocol v1 frame codec, main-loop scaffold, bridge plumbing, sent-cache, and test harness."
+readme = "README.md"
+license = "Apache-2.0"
+requires-python = ">=3.10"
+dependencies = ["cbor2"]
+
+[project.urls]
+Homepage = "https://docs.relayfabric.org"
+Repository = "https://github.com/RelayFabric/RelayFabric"
+
+# Not pip-installed by anything in-repo: plugins and their tests consume
+# this package via a sys.path insert to ../../sdk/python. `pip install -e
+# sdk/python` works for out-of-repo consumption but is not required.
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+include = ["relayfabric_sdk*"]

relayfabric_sdk-0.4.0/relayfabric_sdk/__init__.py

@@ -0,0 +1,25 @@
+"""RelayFabric Python plugin SDK.
+
+Consolidates what the plugin fleet shares: the Plugin Protocol v1 frame
+codec (ipc), the sent-message loop-guard cache (cache), shared Bridge
+plumbing (bridge), the main-loop scaffold (runner), the scripted-socket
+test double (harness), and the NIP-01 event primitives (nip01).
+
+Plugins import submodules directly (`from relayfabric_sdk import ipc as
+relay_ipc`). The flat names below resolve lazily (PEP 562), so a bare
+`import relayfabric_sdk` — or importing the stdlib-only `bridge`
+submodule — pulls in no third-party dependency.
+"""
+
+_FLAT = {"FakeSock": "harness", "SentCache": "cache", "run_plugin": "runner"}
+
+__all__ = list(_FLAT)
+
+
+def __getattr__(name):
+    submodule = _FLAT.get(name)
+    if submodule is None:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+    from importlib import import_module
+
+    return getattr(import_module(f".{submodule}", __name__), name)

relayfabric_sdk-0.4.0/relayfabric_sdk/bridge.py

@@ -0,0 +1,71 @@
+"""Shared Bridge plumbing for the plugin fleet.
+
+Module top level is stdlib-only (the package __init__ is lazy, so importing
+this from a plugin's module top level pulls no cbor2/paho/etc.); ipc is
+imported inside the functions that write frames, mirroring the plugins'
+own lazy-import convention.
+"""
+
+import logging
+import threading
+
+log = logging.getLogger(__name__)
+
+
+class FrameWriter:
+    """Owns the daemon socket file and the write lock every Bridge
+    re-declared: all daemon-socket writes go through _send_frame, serialized
+    by one lock (handle_event runs on a backend reader thread, handle_send
+    on the main thread).
+    """
+
+    def __init__(self, sock_file):
+        self.sock_file = sock_file
+        self.write_lock = threading.Lock()
+
+    def _send_frame(self, obj):
+        from . import ipc
+
+        with self.write_lock:
+            ipc.write_frame(self.sock_file, obj)
+
+
+def capped_text_send(bridge, frame, label, sent_what, publish):
+    """The endpoint-lookup -> size-cap -> publish -> delivery_result dance
+    four plugins carried verbatim (differing only in label and publish call).
+
+    `bridge` needs: cfg["channels"], cfg["max_text_bytes"], _send_frame,
+    sent_cache. `publish(channel_spec, endpoint, body)` raises on failure.
+    """
+    from . import ipc
+
+    corr = frame["corr"]
+    endpoint = frame["endpoint"]
+    body = frame["body"]
+    channel_spec = bridge.cfg["channels"].get(endpoint)
+    if channel_spec is None:
+        log.warning(f"{label} send to unknown endpoint {endpoint!r}")
+        bridge._send_frame(ipc.delivery_result(corr, False, "unknown endpoint"))
+        return
+
+    body_bytes = len(body.encode("utf-8"))
+    max_bytes = bridge.cfg["max_text_bytes"]
+    if body_bytes > max_bytes:
+        # defensive: the daemon should have already truncated to the
+        # advertised capabilities.max_payload before sending this frame.
+        detail = f"body {body_bytes} B exceeds max_text_bytes {max_bytes} B"
+        log.warning(f"{label} send to '{endpoint}' dropped: {detail}")
+        bridge._send_frame(ipc.delivery_result(corr, False, detail))
+        return
+
+    try:
+        publish(channel_spec, endpoint, body)
+    except Exception as e:  # noqa: BLE001 - report the failure, don't crash
+        log.warning(f"{label} send to '{endpoint}' failed: {e}")
+        bridge._send_frame(ipc.delivery_result(corr, False, str(e)))
+        return
+    # delivered = send accepted by the backend (spec Sec70), not an
+    # end-to-end delivery acknowledgement.
+    bridge.sent_cache.record(endpoint, body)
+    bridge._send_frame(ipc.delivery_result(corr, True))
+    log.info(f"Sent {sent_what} to '{endpoint}' ({body_bytes} B)")

relayfabric_sdk-0.4.0/relayfabric_sdk/cache.py

@@ -0,0 +1,36 @@
+"""SentCache: loop guard for echoes of our own bridged posts.
+
+Moved from plugins/signal/relayfabric_signal.py into the SDK. Signal uses
+it to catch linked-device sync echoes; meshtastic and meshcore use it
+(with a shorter ttl_secs) to catch radio/firmware echoes of their own
+downlinked messages.
+"""
+
+import threading
+import time
+
+
+class SentCache:
+    """Loop guard for linked-device sync echoes of our own bridged posts."""
+
+    def __init__(self, ttl_secs=86400):
+        self.ttl = ttl_secs
+        self._entries = {}
+        self._lock = threading.Lock()
+
+    def record(self, group_id, text, now=None):
+        now = time.time() if now is None else now
+        with self._lock:
+            self._prune(now)
+            self._entries[(group_id, text)] = now
+
+    def match(self, group_id, text, now=None):
+        now = time.time() if now is None else now
+        with self._lock:
+            self._prune(now)
+            return self._entries.pop((group_id, text), None) is not None
+
+    def _prune(self, now):
+        # O(n) prune per call, fine at gateway volumes
+        for key in [k for k, t in self._entries.items() if now - t > self.ttl]:
+            del self._entries[key]

relayfabric_sdk-0.4.0/relayfabric_sdk/harness.py

@@ -0,0 +1,40 @@
+"""FakeSock: scripted duplex socket double for plugin frame-IO tests.
+
+Superset of the write-capture-only fake each plugin suite used to
+re-implement locally (lxmf/signal/meshtastic/meshcore all had a
+byte-identical copy): construct with no arguments for the common case
+(capture frames a Bridge writes via write_frame(), decode them back with
+frames()); optionally pass queued_frames to script the read side too
+(read_frame() consumes them in order, then hits EOFError once exhausted,
+mirroring a closed daemon connection) for main-loop-style tests.
+"""
+
+import io
+
+from . import ipc
+
+
+class FakeSock:
+    def __init__(self, queued_frames=None):
+        self._in = io.BytesIO()
+        for obj in queued_frames or []:
+            ipc.write_frame(self._in, obj)
+        self._in.seek(0)
+        self._out = io.BytesIO()
+
+    def read(self, n):
+        return self._in.read(n)
+
+    def write(self, data):
+        self._out.write(data)
+
+    def flush(self):
+        pass
+
+    def frames(self):
+        out, rd = [], io.BytesIO(self._out.getvalue())
+        while True:
+            try:
+                out.append(ipc.read_frame(rd))
+            except EOFError:
+                return out

relayfabric_sdk-0.4.0/relayfabric_sdk/ipc.py

@@ -0,0 +1,104 @@
+"""RelayFabric Plugin Protocol v1 codec: 4-byte BE length prefix + CBOR.
+
+Moved from plugins/lxmf/relay_ipc.py into the SDK so the fleet (lxmf,
+signal, meshtastic, meshcore) shares one copy instead of importing across
+plugin directories.
+
+Dict key order matters: frames must be byte-identical to the Rust
+relay-ipc encoding (locked by canonical_hello_frame_bytes_are_stable).
+"""
+
+from datetime import datetime, timezone
+
+import cbor2
+
+MAX_FRAME = 16 * 1024 * 1024
+PROTOCOL_VERSION = 1
+
+
+def write_frame(fileobj, obj):
+    body = cbor2.dumps(obj)
+    if len(body) > MAX_FRAME:
+        raise ValueError(f"frame {len(body)} B exceeds MAX_FRAME")
+    fileobj.write(len(body).to_bytes(4, "big") + body)
+    fileobj.flush()
+
+
+def _read_exact(fileobj, n):
+    data = b""
+    while len(data) < n:
+        chunk = fileobj.read(n - len(data))
+        if not chunk:
+            raise EOFError("daemon connection closed")
+        data += chunk
+    return data
+
+
+def read_frame(fileobj):
+    length = int.from_bytes(_read_exact(fileobj, 4), "big")
+    if length > MAX_FRAME:
+        raise ValueError(f"frame {length} B exceeds MAX_FRAME")
+    return cbor2.loads(_read_exact(fileobj, length))
+
+
+def capabilities(**overrides):
+    caps = {
+        "text": True, "direct_messages": False, "groups": False,
+        "attachments": False, "location": False, "reactions": False,
+        "receipts": False, "presence": False, "max_payload": None,
+    }
+    caps.update(overrides)
+    return caps
+
+
+def hello(plugin, version, caps):
+    return {"t": "hello", "plugin": plugin, "version": version,
+            "protocol_version": PROTOCOL_VERSION, "capabilities": caps}
+
+
+def attachment(filename, mime, data):
+    """Create an attachment dict for inbound frames.
+
+    Args:
+        filename: attachment filename
+        mime: MIME type string
+        data: bytes payload (encoded as CBOR byte string)
+
+    Returns:
+        dict with filename, mime, data keys
+    """
+    return {"filename": filename, "mime": mime, "data": data}
+
+
+def inbound(endpoint, sender, body, created_at_epoch=None, *, attachments=None, priority=None):
+    created = None
+    if created_at_epoch is not None:
+        try:
+            created = (datetime.fromtimestamp(created_at_epoch, timezone.utc)
+                       .isoformat().replace("+00:00", "Z"))
+        except (OverflowError, OSError, ValueError):
+            # sender-controlled timestamp out of range (e.g. 1e300); bridge
+            # the message anyway and let the daemon stamp receive time.
+            created = None
+    return {"t": "inbound", "endpoint": endpoint, "sender": sender,
+            "kind": "text", "body": body, "created_at": created,
+            "attachments": attachments or [], "priority": priority}
+
+
+def delivery_result(corr, delivered, detail=None):
+    return {"t": "delivery_result", "corr": corr, "delivered": delivered,
+            "detail": detail}
+
+
+def gauges(values):
+    """Create a Gauges frame (design §3, cycle D) from a dict of gauge name
+    -> numeric value.
+
+    Mirrors the Rust side's `PluginToDaemon::Gauges { gauges: BTreeMap<String,
+    f64> }`: keys are sorted here too, so a frame built from the same
+    name/value set on either side of the wire encodes identically. Values are
+    coerced to float (BTreeMap<String, f64> on the Rust side has no integer
+    variant). Name sanitization and the 32-gauge cap are enforced daemon-side
+    on receipt, not here.
+    """
+    return {"t": "gauges", "gauges": {k: float(values[k]) for k in sorted(values)}}

relayfabric_sdk-0.4.0/relayfabric_sdk/nip01.py

@@ -0,0 +1,124 @@
+"""NIP-01 event primitives: canonical event id, schnorr sign/verify, and
+identity load/generate.
+
+Moved verbatim from plugins/nostr/relayfabric_nostr.py (cycle J): NIP-01
+event id/sig are protocol-frozen (BIP-340 schnorr over the exact canonical
+`[0, pubkey, created_at, kind, tags, content]` serialization), so this is a
+shared primitive like ipc/cache/harness rather than nostr-plugin-specific
+code -- the bitchat plugin imports the same functions so there is one
+tested copy of the crypto, not two copies that can drift.
+
+Module top level is stdlib-only (hashlib/json/logging/os); coincurve is
+imported lazily inside verify_event/sign_event/load_or_create_identity (the
+fleet's lazy-import convention) so this module stays importable without
+coincurve installed.
+"""
+
+import hashlib
+import json
+import logging
+import os
+
+log = logging.getLogger(__name__)
+
+
+def event_id(pubkey_hex, created_at, kind, tags, content):
+    """NIP-01 event id: sha256 hex of the canonical serialization
+    `[0, pubkey, created_at, kind, tags, content]` -- compact separators,
+    UTF-8, no extra whitespace, exactly as NIP-01 specifies. See
+    test_relayfabric_nostr.py's EventIdGoldenVectorTests for the locked
+    known-answer vector (nsec=1, the secp256k1 generator scalar).
+    """
+    serialized = json.dumps(
+        [0, pubkey_hex, created_at, kind, tags, content],
+        separators=(",", ":"), ensure_ascii=False)
+    return hashlib.sha256(serialized.encode("utf-8")).hexdigest()
+
+
+def verify_event(event):
+    """True iff event's id matches the recomputed NIP-01 sha256 AND its
+    schnorr sig verifies (BIP-340) over that id, under event['pubkey'].
+
+    MUST NOT raise: a relay sends arbitrary dicts (design Sec80 -- a relay
+    is untrusted), so any KeyError/TypeError/ValueError from a malformed or
+    adversarial event (missing keys, wrong types, non-hex/wrong-length
+    id/pubkey/sig, non-dict input entirely) is caught and treated as an
+    invalid event, never propagated.
+    """
+    try:
+        pubkey_hex = event["pubkey"]
+        created_at = event["created_at"]
+        kind = event["kind"]
+        tags = event["tags"]
+        content = event["content"]
+        claimed_id = event["id"]
+        sig_hex = event["sig"]
+
+        recomputed_id = event_id(pubkey_hex, created_at, kind, tags, content)
+        if recomputed_id != claimed_id:
+            return False
+
+        from coincurve import PublicKeyXOnly
+
+        pub = PublicKeyXOnly(bytes.fromhex(pubkey_hex))
+        return pub.verify(bytes.fromhex(sig_hex), bytes.fromhex(recomputed_id))
+    except Exception:  # noqa: BLE001 - malformed/adversarial input, never propagate
+        return False
+
+
+def sign_event(privkey_hex, created_at, kind, tags, content):
+    """Build a full signed NIP-01 event {id, pubkey, created_at, kind, tags,
+    content, sig} from a 32-byte hex private key ("nsec hex", design Sec1 --
+    the raw hex form, not bech32). Round-trips through verify_event().
+    """
+    from coincurve import PrivateKey, PublicKeyXOnly
+
+    priv = PrivateKey(bytes.fromhex(privkey_hex))
+    pubkey_hex = PublicKeyXOnly.from_valid_secret(priv.secret).format().hex()
+    eid = event_id(pubkey_hex, created_at, kind, tags, content)
+    sig_hex = priv.sign_schnorr(bytes.fromhex(eid)).hex()
+    return {
+        "id": eid,
+        "pubkey": pubkey_hex,
+        "created_at": created_at,
+        "kind": kind,
+        "tags": tags,
+        "content": content,
+        "sig": sig_hex,
+    }
+
+
+def load_or_create_identity(identity_file):
+    """Load this plugin's Nostr keypair, generating one on first run.
+
+    If `identity_file` is set and already holds a key (one line, 32-byte
+    hex privkey -- the same "nsec hex" form sign_event takes), load it.
+    Otherwise generate a fresh secp256k1 key via coincurve; if
+    `identity_file` is set, persist the new key there with mode 0600
+    (os.open O_CREAT so the restrictive mode is atomic with creation, no
+    window where the key sits world-readable) so restarts reuse the same
+    identity. A None `identity_file` means a fresh identity every start
+    (no path to persist to) -- config-valid per load_config, but every
+    restart then publishes under a new pubkey.
+
+    Logs the public key (hex; loosely "npub", though this is the raw hex
+    form, not bech32) exactly once. Never logs the private key.
+
+    Returns (privkey_hex, pubkey_hex).
+    """
+    from coincurve import PrivateKey, PublicKeyXOnly
+
+    if identity_file and os.path.exists(identity_file):
+        with open(identity_file) as f:
+            privkey_hex = f.read().strip()
+    else:
+        privkey_hex = PrivateKey().secret.hex()
+        if identity_file:
+            fd = os.open(identity_file, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+            with os.fdopen(fd, "w") as f:
+                f.write(privkey_hex + "\n")
+
+    pubkey_hex = PublicKeyXOnly.from_valid_secret(
+        PrivateKey(bytes.fromhex(privkey_hex)).secret).format().hex()
+    log.info(f"Nostr identity pubkey (npub, hex): {pubkey_hex}")
+    return privkey_hex, pubkey_hex

relayfabric_sdk-0.4.0/relayfabric_sdk/runner.py

@@ -0,0 +1,107 @@
+"""run_plugin: shared main-loop scaffold for the plugin fleet.
+
+Consolidates the env contract -> Hello/HelloAck handshake -> dispatch-table
+read loop that lxmf/signal/meshtastic/meshcore each hand-rolled identically
+in their main() functions. A plugin adopts it by building a `bridge_factory`
+(cfg_dict, sock) -> object with a `handle_send(frame)` method, and calling
+`run_plugin(name, version, bridge_factory, capabilities)`.
+
+`connect` is a dependency-injection seam for tests only: it defaults to a
+real AF_UNIX connect + a single duplex `sock.makefile("rwb")` (one object
+used for both read_frame and write_frame, exactly like FakeSock), and every
+real caller leaves it at the default.
+"""
+
+import json
+import os
+import socket
+import sys
+
+from .ipc import hello, read_frame, write_frame
+
+
+def _connect_socket(sock_path):
+    sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+    sock.connect(sock_path)
+    return sock.makefile("rwb")
+
+
+def run_plugin(plugin_name, version, bridge_factory, capabilities, *,
+                socket_env="RELAYFABRIC_SOCKET", config_env="RELAYFABRIC_PLUGIN_CONFIG",
+                connect=_connect_socket):
+    """Run a plugin's main loop until shutdown or an unrecoverable error.
+
+    - Missing `socket_env` -> stderr line + exit 2.
+    - Connects, sends Hello(plugin_name, version, capabilities), reads
+      HelloAck; a non-"hello_ack" frame or a truthy "error" -> stderr line +
+      exit 1. `capabilities` may be a callable taking the parsed config dict
+      and returning the caps dict, for plugins whose advertised caps depend
+      on config (e.g. a config-derived max_payload).
+    - Calls `bridge_factory(cfg_dict, sock)`; if the returned object has a
+      `start()`, calls it before entering the read loop.
+    - A ValueError/TypeError from the capabilities callable or
+      bridge_factory (the plugins' load_config validation errors) -> clean
+      "invalid config" stderr line + exit 1.
+    - Read loop: "send" -> bridge.handle_send(frame); "send_direct" ->
+      bridge.handle_send_direct(frame) if present, else ignored; "shutdown"
+      -> bridge.stop() if present, then exit 0; unknown "t" -> ignored;
+      (EOFError, OSError, ValueError) while reading -> stderr line + exit 1.
+    """
+    try:
+        sock_path = os.environ[socket_env]
+    except KeyError:
+        print(f"{plugin_name}: missing required env var {socket_env}", file=sys.stderr)
+        sys.exit(2)
+
+    raw_cfg = json.loads(os.environ.get(config_env, "{}"))
+    # Scrub the resolved config (may carry secrets substituted by the daemon
+    # from a ${env:}/${file:} reference) out of our own environment so any
+    # child process this plugin spawns (e.g. lxmf's media.py running ffmpeg
+    # over attacker-supplied audio) doesn't inherit it.
+    os.environ.pop(config_env, None)
+    sock = connect(sock_path)
+
+    try:
+        caps = capabilities(raw_cfg) if callable(capabilities) else capabilities
+    except (ValueError, TypeError) as e:
+        print(f"{plugin_name}: invalid config: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    write_frame(sock, hello(plugin_name, version, caps))
+    ack = read_frame(sock)
+    if ack.get("t") != "hello_ack" or ack.get("error"):
+        print(f"{plugin_name}: hello rejected: {ack.get('error')}", file=sys.stderr)
+        sys.exit(1)
+
+    try:
+        bridge = bridge_factory(raw_cfg, sock)
+    except (ValueError, TypeError) as e:
+        print(f"{plugin_name}: invalid config: {e}", file=sys.stderr)
+        sys.exit(1)
+    start = getattr(bridge, "start", None)
+    if start is not None:
+        start()
+
+    while True:
+        try:
+            frame = read_frame(sock)
+        except (EOFError, OSError, ValueError) as e:
+            # ValueError: oversize/corrupt frame (read_frame's own MAX_FRAME
+            # check). The stream is desynced at that point, so exit rather
+            # than continue -- there is no way to resume mid-frame.
+            print(f"{plugin_name}: daemon connection lost, exiting: {e}", file=sys.stderr)
+            sys.exit(1)
+
+        kind = frame.get("t")
+        if kind == "send":
+            bridge.handle_send(frame)
+        elif kind == "send_direct":
+            handle_send_direct = getattr(bridge, "handle_send_direct", None)
+            if handle_send_direct is not None:
+                handle_send_direct(frame)
+        elif kind == "shutdown":
+            stop = getattr(bridge, "stop", None)
+            if stop is not None:
+                stop()
+            sys.exit(0)
+        # unknown t: ignore, keep looping

relayfabric_sdk-0.4.0/relayfabric_sdk.egg-info/PKG-INFO

@@ -0,0 +1,25 @@
+Metadata-Version: 2.4
+Name: relayfabric-sdk
+Version: 0.4.0
+Summary: RelayFabric Python plugin SDK: Plugin Protocol v1 frame codec, main-loop scaffold, bridge plumbing, sent-cache, and test harness.
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://docs.relayfabric.org
+Project-URL: Repository, https://github.com/RelayFabric/RelayFabric
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: cbor2
+
+# relayfabric-sdk
+
+The Python side of RelayFabric's Plugin Protocol v1: the CBOR frame codec
+(`relayfabric_sdk.ipc`, golden-locked byte-for-byte against the Rust
+implementation), the `run_plugin` main-loop scaffold, shared Bridge plumbing
+(`relayfabric_sdk.bridge`), the sent-message loop-guard cache, and the
+`FakeSock` test harness.
+
+A complete plugin is ~30 lines — see `examples/echo_plugin.py`. Prove any
+plugin against the daemon-side contract with:
+
+    switchyardctl plugin test "python my_plugin.py"
+
+Docs: https://docs.relayfabric.org/plugin-authors/

relayfabric_sdk-0.4.0/relayfabric_sdk.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+README.md
+pyproject.toml
+relayfabric_sdk/__init__.py
+relayfabric_sdk/bridge.py
+relayfabric_sdk/cache.py
+relayfabric_sdk/harness.py
+relayfabric_sdk/ipc.py
+relayfabric_sdk/nip01.py
+relayfabric_sdk/runner.py
+relayfabric_sdk.egg-info/PKG-INFO
+relayfabric_sdk.egg-info/SOURCES.txt
+relayfabric_sdk.egg-info/dependency_links.txt
+relayfabric_sdk.egg-info/requires.txt
+relayfabric_sdk.egg-info/top_level.txt
+tests/test_bridge.py
+tests/test_cache.py
+tests/test_ipc.py
+tests/test_nip01.py
+tests/test_runner.py

relayfabric_sdk-0.4.0/relayfabric_sdk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

relayfabric_sdk-0.4.0/relayfabric_sdk.egg-info/requires.txt

@@ -0,0 +1 @@
+cbor2

relayfabric_sdk-0.4.0/relayfabric_sdk.egg-info/top_level.txt

@@ -0,0 +1 @@
+relayfabric_sdk

relayfabric_sdk-0.4.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+