1 files changed, 83 insertions, 0 deletions
diff --git a/packages/meshbay-node/src/meshbay_node/blocklist.py b/packages/meshbay-node/src/meshbay_node/blocklist.py
new file mode 100644
index 0000000..29d8666
--- /dev/null
+++ b/packages/meshbay-node/src/meshbay_node/blocklist.py
@@ -0,0 +1,83 @@
+"""
+The hub's content blocklist, as this node applies it (docs/MESHBAY_DESIGN.md §7.5).
+
+Hashes of public content that the hub's moderation has blocked. A node hosting a
+public group stops serving those files there: they leave the index members are
+sent, and a request for one is refused. Nothing is deleted from the operator's
+disk — the node stops serving, and what the operator keeps is theirs to decide.
+
+Private groups are untouched. The hub never learns what a private group holds,
+so there is nothing it could have blocked in one, and nothing here reaches them.
+
+Kept on disk as well as in memory, so a node that restarts while the hub is
+unreachable does not serve again, meanwhile, what it had already stopped serving.
+The hub's list is the authority: a full sync replaces this one.
+
+It is an exact match on the content id. A file changed by one byte is another
+id, and files over the partial-hash threshold are identified by a sample of their
+bytes (§6.3) — a moderation tool, not a guarantee.
+"""
+
+import json
+import logging
+import os
+import re
+from pathlib import Path
+
+log = logging.getLogger(__name__)
+
+_HASH = re.compile(r"^[0-9a-f]{64}$")
+
+
+class ContentBlocklist:
+    def __init__(self, path: Path | None = None):
+        self._path = path
+        self._hashes: set[str] = set()
+        if path is not None:
+            try:
+                data = json.loads(path.read_text(encoding="utf-8"))
+                self._hashes = {h for h in data.get("hashes", []) if _HASH.match(h)}
+            except FileNotFoundError:
+                pass
+            except (OSError, ValueError) as e:
+                # A damaged file is not a reason to refuse to start; the next
+                # sync with the hub rewrites it.
+                log.warning("Content blocklist %s unreadable: %s", path, e)
+
+    def __contains__(self, content_hash: object) -> bool:
+        return content_hash in self._hashes
+
+    def __len__(self) -> int:
+        return len(self._hashes)
+
+    def __iter__(self):
+        return iter(self._hashes)
+
+    def replace(self, hashes) -> bool:
+        """The hub's full list. True when it differs from what was applied."""
+        new = {h for h in hashes if isinstance(h, str) and _HASH.match(h)}
+        if new == self._hashes:
+            return False
+        self._hashes = new
+        self._save()
+        return True
+
+    def apply(self, add=(), remove=()) -> bool:
+        """One pushed change. True when it changed anything."""
+        before = set(self._hashes)
+        self._hashes |= {h for h in add if isinstance(h, str) and _HASH.match(h)}
+        self._hashes -= {h for h in remove if isinstance(h, str)}
+        if self._hashes == before:
+            return False
+        self._save()
+        return True
+
+    def _save(self) -> None:
+        if self._path is None:
+            return
+        tmp = self._path.with_suffix(".tmp")
+        try:
+            tmp.write_text(json.dumps({"hashes": sorted(self._hashes)}), encoding="utf-8")
+            os.replace(tmp, self._path)
+        except OSError as e:
+            log.warning("Content blocklist %s not saved: %s", self._path, e)