witbitz-code 1.7.1__tar.gz → 1.7.2__tar.gz

{witbitz_code-1.7.1/src/witbitz_code.egg-info → witbitz_code-1.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: witbitz-code
-Version: 1.7.1
+Version: 1.7.2
 Summary: Reach OpenCode on this computer from the Witbitz Spaces Code section, through an end-to-end sealed relay.
 Author: Witbitz
 License-Expression: MIT

{witbitz_code-1.7.1 → witbitz_code-1.7.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "witbitz-code"
-version = "1.7.1"
+version = "1.7.2"
 description = "Reach OpenCode on this computer from the Witbitz Spaces Code section, through an end-to-end sealed relay."
 readme = "README.md"
 requires-python = ">=3.10"

{witbitz_code-1.7.1 → witbitz_code-1.7.2}/src/witbitz_code/__init__.py

@@ -4,4 +4,4 @@ The Python implementation of tools/witbitz-code.mjs (docs/opencode-relay.md phas
 vectors and cross-implementation tests.
 """
 
-__version__ = "1.7.1"
+__version__ = "1.7.2"

{witbitz_code-1.7.1 → witbitz_code-1.7.2}/src/witbitz_code/connector.py

@@ -35,7 +35,8 @@ from .asks import ASK_FRAME, AskBook
 from .folders import FOLDER_ROUTE, folder_route
 from .attachments import (ATTACHMENT_ROUTE, MAX_FILE_BYTES, attachment_rule, default_root, prune_attachments,
                           remove_session_attachments, serve_attachment, stage_message_body)
-from .auto_runner import AutoRunner
+from .auto_runner import AutoRunner, detail_of
+from .remind import ReminderClock, seal as seal_remind, valid as valid_remind  # "waiting for your approval" (docs/approval-reminders.md)
 from .outputs import OUTPUT_ROUTE, serve_output
 from .plugins import notes_plugin_path as default_notes_plugin, notes_root as default_notes_root, notes_rules
 from .payers import SessionPayers
@@ -53,6 +54,7 @@ REQUEST_TIMEOUT_MS = 30_000
 HELLO_EVERY_S = 20.0  # the page counts the computer online while a hello arrived in the last 30 s
 SUB_TTL_S = 75.0  # a page re-subscribes every 30 s; a client that stops renewing is dropped
 SWEEP_EVERY_S = 15.0
+REMIND_EVERY_S = 15.0  # how often waiting approvals are checked for a due tickle (remind.py)
 ASKS_RECONCILE_MS = 30_000  # how often recorded asks are checked against which sessions still run (asks.py)
 MAX_RESPONSE = 30 * 1024 * 1024  # bytes; below the page's 32 MiB reassembly cap: refuse while reading, not by a timeout
 START_HINT = "witbitz-code serve"
@@ -158,7 +160,7 @@ class PairingServer:
                  attach_root: Path | None = None, attach_max_file_bytes: int = MAX_FILE_BYTES,
                  asks_reconcile_ms: float = ASKS_RECONCILE_MS, notes_root: str | None = None,
                  notes_plugin_path: Path | None = None, payers: SessionPayers | None = None,
-                 model_url: str = "") -> None:
+                 model_url: str = "", remind_times: dict | None = None) -> None:
         self.pairing = pairing
         self._security: seccheck.SecurityCheck | None = None  # read on the first ask (seccheck.py)
         # WHO PAYS (payers.py): this pairing's account owns the turns it starts; the proxy bills each call to its owner.
@@ -170,6 +172,10 @@ class PairingServer:
         # WHAT IS WAITING (asks.py): OpenCode's GET /permission breaks for a whole folder on one malformed ask and keeps a
         # stopped turn's asks — every folder's asks are followed on /global/event, for Auto and for the page's card recovery.
         self._asks = AskBook()
+        rt = remind_times or {}  # tests: {first_s, second_s, every_s, allow_http}
+        self._remind_rt = rt
+        self._remind = ReminderClock(**{k: rt[k] for k in ("first_s", "second_s") if rt.get(k)})  # who to tickle when an approval waits (remind.py)
+        self._remind_parent: dict[str, str] = {}  # a subagent's session → its parent's
         self._asks_live = False
         self._asks_epoch = 0  # one per connection of the stream
         self._asks_complete: dict[str, int] = {}  # directory → the epoch its whole list was read in: the book knows every ask since
@@ -219,6 +225,7 @@ class PairingServer:
     # ── lifecycle ─────────────────────────────────────────────────────────────────────────────────────────────────────
     async def start(self) -> None:
         self._spawn(self._every(SWEEP_EVERY_S, self._sweep))
+        self._spawn(self._every(self._remind_rt.get("every_s") or REMIND_EVERY_S, lambda: self._spawn(self._remind_tick())))
         self._spawn(self._every(HELLO_EVERY_S, lambda: self.hello() if self.peer.peers >= 2 else None))
         self._spawn(self._watch_asks())
         self._spawn(self._every(self._asks_reconcile_s, lambda: self._spawn(self._reconcile_asks()) if self._asks_live else None))
@@ -288,7 +295,7 @@ class PairingServer:
             return None  # no hello before this socket has its nonce
         # caps: what this connector can do beyond the requests — a page shows the Auto switch only when `auto` is here.
         return self.peer.send({"t": "hello", "ver": VERSION, "name": self.name, "computerId": self.pairing.get("computerId") or "",
-                               "k": self.nonce, "ts": int(time.time() * 1000), "caps": ["auto", "attachments", "outputs", "tools", "seen", "asks", "folders"], "auto": self.auto.sessions()})
+                               "k": self.nonce, "ts": int(time.time() * 1000), "caps": ["auto", "attachments", "outputs", "tools", "seen", "asks", "folders", "remind"], "auto": self.auto.sessions()})
 
     def _auth(self) -> dict:
         pw = self.pairing.get("password") or read_env_password(Path(self.pairing["envFile"]) if self.pairing.get("envFile") else None)
@@ -317,6 +324,11 @@ class PairingServer:
             # page that can switch Auto could already answer the same asks itself.
             if current and self.auto.set_auto(m.get("sid"), m.get("dir"), _js.truthy(m.get("on"))):
                 self.hello()
+        elif t == "remind":
+            # "Waiting for your approval" (remind.py): the device that sent a prompt, for the asks it leads to. Nonce-checked.
+            e = valid_remind(m, allow_http=bool(self._remind_rt.get("allow_http"))) if current else None
+            if e:
+                self._remind.note(m["sid"], e)
         elif t == "tools":
             # Which suggested tools this computer has (spaces/public/codeTools.js) — a PATH lookup, nonce-checked like a request.
             if current:
@@ -487,6 +499,52 @@ class PairingServer:
             if paid:
                 self._payers.end(paid.group(1))
 
+    async def _remind_owner(self, sid: str, directory: str) -> str:
+        """The session a page named for reminders: this one, or the nearest parent (a subagent's ask)."""
+        cur = sid
+        for _ in range(4):
+            if self._remind.who(cur):
+                return cur
+            parent = self._remind_parent.get(cur)
+            if parent is None:
+                try:
+                    st, text = await self._opencode("GET", f"/session/{urllib.parse.quote(cur, safe=_URI_SAFE)}", directory)
+                    data = _js.parse(text) if 200 <= st < 300 else None
+                except asyncio.CancelledError:
+                    raise
+                except Exception:
+                    return ""
+                parent = data.get("parentID") if isinstance(data, dict) and isinstance(data.get("parentID"), str) else ""
+                self._remind_parent[cur] = parent
+                if len(self._remind_parent) > 2000:
+                    del self._remind_parent[next(iter(self._remind_parent))]
+            if not parent:
+                return ""
+            cur = parent
+        return ""
+
+    async def _remind_tick(self) -> None:
+        """Each waiting approval: a tickle at one minute and a reminder at ten, to the device whose prompt led to it."""
+        if not self._asks_live:
+            return
+        for directory in self._asks.directories():
+            for ask, stage in self._remind.due(self._asks.list(directory)):
+                self._remind.sent(ask["id"], stage)
+                owner = await self._remind_owner(ask["sessionID"], directory)
+                e = self._remind.who(owner) if owner else None
+                if not e:
+                    continue
+                n = seal_remind(e["key"], {"where": self.name, "what": detail_of(ask) or str(ask.get("permission") or ""),
+                                           "computer": self.pairing.get("computerId") or "", "session": owner})
+                try:
+                    r = await self._client.post(e["url"], json={"op": "coderemind", "grant": e["grant"], "n": n}, timeout=15)
+                    if r.status_code == 410:
+                        self._remind.note(owner, {})  # that device's address is gone: nothing more to it
+                except asyncio.CancelledError:
+                    raise
+                except Exception:
+                    pass  # offline: the next stage tries again
+
     def _own_review(self, session: str, start: bool) -> None:
         if not self._payers:
             return
@@ -883,7 +941,7 @@ async def start_connector(pairings: list[dict], *, flush_ms: float = 120, log: C
                           attach_root: Path | None = None, attach_max_file_bytes: int = MAX_FILE_BYTES,
                           asks_reconcile_ms: float = ASKS_RECONCILE_MS, notes_root: str | None = None,
                           notes_plugin_path: Path | None = None, payers: SessionPayers | None = None,
-                          model_url: str = "") -> Connector:
+                          model_url: str = "", remind_times: dict | None = None) -> Connector:
     """Serve the given pairings until stop()/aclose(). Options exist for tests: flush_ms, log, client, connect,
     request_timeout_ms, max_senders, max_response_bytes, auto_dir, auto_poll_ms."""
     client = client or local_client()
@@ -898,7 +956,7 @@ async def start_connector(pairings: list[dict], *, flush_ms: float = 120, log: C
         s = PairingServer(p, client=client, flush_ms=flush_ms, log=log, connect=connect, request_timeout_ms=request_timeout_ms,
                           max_senders=max_senders, max_response_bytes=max_response_bytes, auto_dir=auto_dir, auto_poll_ms=auto_poll_ms,
                           attach_root=attach_root, attach_max_file_bytes=attach_max_file_bytes, asks_reconcile_ms=asks_reconcile_ms,
-                          notes_root=notes_root, notes_plugin_path=notes_plugin_path, payers=payers, model_url=model_url)
+                          notes_root=notes_root, notes_plugin_path=notes_plugin_path, payers=payers, model_url=model_url, remind_times=remind_times)
         await s.start()
         servers.append(s)
     return Connector(servers, client, payers)

witbitz_code-1.7.2/src/witbitz_code/remind.py

@@ -0,0 +1,89 @@
+""""CODE IS WAITING FOR YOUR APPROVAL" — tools/code-remind.mjs, in Python (docs/approval-reminders.md).
+
+The device that sends a prompt hands this computer {t:'remind', sid, grant, key, url} with it: its push address, signed by
+the server (the grant), and a key of its own. When an approval in that session (or a subagent's under it) is still waiting
+a minute later, and again at ten, the computer seals what is waiting under the device's key and asks the server to push it
+to the grant's address (op `coderemind`). The server checks its own signature and a rate, and cannot read the text; the
+device's service worker opens it (spaces/public/sw-notif-core.js wbxCodeRemindOpen) and a tap opens Code at the session.
+"""
+
+from __future__ import annotations
+
+import base64
+import json
+import os
+import re
+import time
+from collections.abc import Callable
+from typing import Any
+
+from cryptography.hazmat.primitives.ciphers.aead import AESGCM
+
+FIRST_S = 60  # the first tickle — an approval nobody has answered for a minute
+SECOND_S = 600  # and the reminder at ten
+MAX_SESSIONS = 200
+AAD = b"witbitz-code-remind"
+GRANT = re.compile(r"^[A-Za-z0-9_-]{20,2400}\.[A-Za-z0-9_-]{20,100}$")
+KEY = re.compile(r"^[A-Za-z0-9_-]{43}$")
+
+
+def _b64u_dec(s: str) -> bytes:
+    return base64.urlsafe_b64decode(s + "=" * (-len(s) % 4))
+
+
+def seal(key_b64u: str, obj: dict) -> str:
+    """AES-256-GCM under the device's key: base64url(iv | ciphertext+tag), what wbxCodeRemindOpen opens."""
+    iv = os.urandom(12)
+    ct = AESGCM(_b64u_dec(key_b64u)).encrypt(iv, json.dumps(obj, separators=(",", ":")).encode("utf-8"), AAD)
+    return base64.urlsafe_b64encode(iv + ct).decode("ascii").rstrip("=")
+
+
+def valid(m: Any, allow_http: bool = False) -> dict | None:
+    """A page's {t:'remind'} → the entry to keep, or None."""
+    if not isinstance(m, dict):
+        return None
+    sid, grant, key, url = m.get("sid"), m.get("grant"), m.get("key"), m.get("url")
+    if not (isinstance(sid, str) and 0 < len(sid) <= 120 and isinstance(grant, str) and GRANT.match(grant)
+            and isinstance(key, str) and KEY.match(key) and isinstance(url, str) and re.match(r"^https?://[^\s/]+(/[^\s]*)?$" if allow_http else r"^https://[^\s/]+(/[^\s]*)?$", url) and len(url) <= 300):
+        return None
+    return {"grant": grant, "key": key, "url": url}
+
+
+class ReminderClock:
+    """Which device each session reminds, and which asks have had which tickle. `now` in seconds."""
+
+    def __init__(self, now: Callable[[], float] = time.monotonic, first_s: float = FIRST_S, second_s: float = SECOND_S) -> None:
+        self._now = now
+        self._first, self._second = first_s, second_s
+        self._by_session: dict[str, dict] = {}
+        self._seen: dict[str, dict] = {}  # ask id → {at, sent: 0|1|2}
+
+    def note(self, sid: str, entry: dict) -> None:
+        self._by_session.pop(sid, None)
+        self._by_session[sid] = entry
+        while len(self._by_session) > MAX_SESSIONS:
+            del self._by_session[next(iter(self._by_session))]
+
+    def who(self, sid: str) -> dict | None:
+        return self._by_session.get(sid)
+
+    def due(self, asks: list[dict]) -> list[tuple[dict, int]]:
+        """Of the asks waiting now, the ones whose next tickle is due → [(ask, stage)]; forgets asks no longer waiting."""
+        t = self._now()
+        live = {a["id"] for a in asks if isinstance(a, dict) and isinstance(a.get("id"), str)}
+        for k in [k for k in self._seen if k not in live]:
+            del self._seen[k]
+        out = []
+        for a in asks:
+            if not isinstance(a, dict) or not isinstance(a.get("id"), str):
+                continue
+            s = self._seen.setdefault(a["id"], {"at": t, "sent": 0})
+            age = t - s["at"]
+            stage = 2 if age >= self._second else 1 if age >= self._first else 0
+            if stage > s["sent"]:
+                out.append((a, stage))
+        return out
+
+    def sent(self, ask_id: str, stage: int) -> None:
+        if ask_id in self._seen:
+            self._seen[ask_id]["sent"] = max(self._seen[ask_id]["sent"], stage)

{witbitz_code-1.7.1 → witbitz_code-1.7.2/src/witbitz_code.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: witbitz-code
-Version: 1.7.1
+Version: 1.7.2
 Summary: Reach OpenCode on this computer from the Witbitz Spaces Code section, through an end-to-end sealed relay.
 Author: Witbitz
 License-Expression: MIT

{witbitz_code-1.7.1 → witbitz_code-1.7.2}/src/witbitz_code.egg-info/SOURCES.txt

@@ -38,6 +38,7 @@ src/witbitz_code/ports.py
 src/witbitz_code/qr.py
 src/witbitz_code/receipt.py
 src/witbitz_code/relay.py
+src/witbitz_code/remind.py
 src/witbitz_code/seccheck.py
 src/witbitz_code/seen.py
 src/witbitz_code/tinfoil_read.py
@@ -88,6 +89,7 @@ tests/test_ports.py
 tests/test_ports_win.py
 tests/test_registry.py
 tests/test_relay_codec.py
+tests/test_remind.py
 tests/test_seccheck.py
 tests/test_setup.py
 tests/test_tools_probe.py

{witbitz_code-1.7.1 → witbitz_code-1.7.2}/tests/test_auto.py

@@ -599,7 +599,7 @@ def test_wiring_the_page_switches_auto_and_the_verdict_comes_back(make, tmp_path
             client = PyClient(rig.secret, rig.relay.url)
             try:
                 await client.start()
-                assert client.hellos()[-1]["caps"] == ["auto", "attachments", "outputs", "tools", "seen", "asks", "folders"]
+                assert client.hellos()[-1]["caps"] == ["auto", "attachments", "outputs", "tools", "seen", "asks", "folders", "remind"]
                 # a stale nonce cannot switch it: a recording cannot turn Auto on
                 await client.peer.send({"t": "auto", "k": "not-the-nonce", "sid": "ses_main", "dir": DIR, "on": True})
                 await asyncio.sleep(0.3)

{witbitz_code-1.7.1 → witbitz_code-1.7.2}/tests/test_connector_e2e.py

@@ -174,7 +174,7 @@ async def conformance(rig: Rig, connector) -> None:
         await client.start()
         hello = client.hellos()[-1]
         assert set(hello) == {"t", "ver", "name", "computerId", "k", "ts", "caps", "auto"} and hello["ver"] == "1"
-        assert (hello["caps"], hello["auto"]) == (["auto", "attachments", "outputs", "tools", "seen", "asks", "folders"], []), "both connectors do Auto mode (test_auto.py), save attachments, serve produced files, share what was seen, keep what is waiting (test_asks.py) and allow a folder (test_folders.py)"
+        assert (hello["caps"], hello["auto"]) == (["auto", "attachments", "outputs", "tools", "seen", "asks", "folders", "remind"], []), "both connectors do Auto mode (test_auto.py), save attachments, serve produced files, share what was seen, keep what is waiting (test_asks.py) and allow a folder (test_folders.py)"
         assert (hello["name"], hello["computerId"]) == ("test-box", "cmp_test") and isinstance(hello["ts"], int)
         assert re.fullmatch(r"[A-Za-z0-9_-]{24}", hello["k"]), "18 random bytes, base64url"
 

witbitz_code-1.7.2/tests/test_remind.py

@@ -0,0 +1,133 @@
+""""Code is waiting for your approval" (witbitz_code/remind.py = tools/code-remind.mjs; docs/approval-reminders.md).
+
+- THE CLOCK: a tickle at one minute, a reminder at ten, never twice, forgotten once the ask is answered.
+- THE TEXT: sealed under the device's key exactly as the service worker opens it (AES-GCM, the shared AAD).
+- BOTH CONNECTORS, for real: a page gives its grant with a prompt, an approval waits, and the computer asks the server to
+  push — twice, with the grant, and text only the device can open.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import base64
+import json
+import os
+import threading
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+
+import pytest
+from conftest import requires_node
+from cryptography.hazmat.primitives.ciphers.aead import AESGCM
+from fakes import until
+from test_connector_e2e import JsConnector, PyClient, PyConnector, Rig, run
+
+from witbitz_code.remind import AAD, ReminderClock, seal, valid
+
+KEY = base64.urlsafe_b64encode(os.urandom(32)).decode().rstrip("=")
+GRANT = "e" * 40 + "." + "s" * 43
+
+
+def opened(n: str) -> dict:
+    b = base64.urlsafe_b64decode(n + "=" * (-len(n) % 4))
+    return json.loads(AESGCM(base64.urlsafe_b64decode(KEY + "=")).decrypt(b[:12], b[12:], AAD))
+
+
+def test_the_clock_tickles_at_one_minute_and_ten_once_each_and_forgets_an_answered_ask():
+    t = [0.0]
+    c = ReminderClock(now=lambda: t[0])
+    ask = {"id": "per_1", "sessionID": "ses_a"}
+    assert c.due([ask]) == []
+    t[0] = 59
+    assert c.due([ask]) == []
+    t[0] = 60
+    assert c.due([ask]) == [(ask, 1)]
+    c.sent("per_1", 1)
+    assert c.due([ask]) == []
+    t[0] = 600
+    assert c.due([ask]) == [(ask, 2)]
+    c.sent("per_1", 2)
+    t[0] = 10_000
+    assert c.due([ask]) == [], "two tickles, then nothing"
+    assert c.due([]) == [] and c.due([ask]) == [], "answered → forgotten; a new ask with that id starts again"
+
+
+def test_the_text_opens_with_the_devices_key_only_and_a_page_message_is_checked():
+    n = seal(KEY, {"what": "npm test"})
+    assert opened(n) == {"what": "npm test"}
+    with pytest.raises(Exception):
+        AESGCM(os.urandom(32)).decrypt(base64.urlsafe_b64decode(n + "=" * (-len(n) % 4))[:12], base64.urlsafe_b64decode(n + "=" * (-len(n) % 4))[12:], AAD)
+    m = {"sid": "ses_a", "grant": GRANT, "key": KEY, "url": "https://witbitz-spaces.pages.dev/space"}
+    assert valid(m) == {"grant": GRANT, "key": KEY, "url": m["url"]}
+    assert valid({**m, "url": "http://127.0.0.1:9/space"}) is None, "https only"
+    assert valid({**m, "key": "short"}) is None and valid({**m, "grant": "x"}) is None and valid({**m, "sid": ""}) is None
+
+
+class Receiver:
+    def __init__(self):
+        self.got: list = []
+        outer = self
+
+        class H(BaseHTTPRequestHandler):
+            def log_message(self, *a):
+                pass
+
+            def do_POST(self):
+                outer.got.append({"path": self.path, "body": json.loads(self.rfile.read(int(self.headers.get("content-length") or 0)))})
+                self.send_response(200)
+                self.send_header("content-type", "application/json")
+                self.end_headers()
+                self.wfile.write(b'{"ok":true}')
+
+        self.httpd = ThreadingHTTPServer(("127.0.0.1", 0), H)
+        self.httpd.daemon_threads = True
+        threading.Thread(target=self.httpd.serve_forever, daemon=True).start()
+        self.url = f"http://127.0.0.1:{self.httpd.server_address[1]}/space"
+
+    def close(self):
+        self.httpd.shutdown()
+        self.httpd.server_close()
+
+
+def _asked(directory, props):
+    return {"directory": directory, "project": "p", "payload": {"id": "evt", "type": "permission.asked", "properties": props}}
+
+
+ASK = {"id": "per_bash", "sessionID": "ses_main", "permission": "bash", "patterns": ["npm test"], "metadata": {"command": "npm test"}, "always": []}
+CONNECTORS = [pytest.param(PyConnector, {"remindTimes": {"first_s": 0.3, "second_s": 1.0, "every_s": 0.1, "allow_http": True}}, id="python"),
+              pytest.param(JsConnector, {"remindTimes": {"firstMs": 300, "secondMs": 1000, "everyMs": 100, "allowHttp": True}}, id="js", marks=requires_node)]
+
+
+@pytest.mark.parametrize("make,opts", CONNECTORS)
+def test_both_connectors_push_a_waiting_approval_to_the_device_that_asked_twice_sealed_to_it(make, opts, tmp_path):
+    rx = Receiver()
+
+    async def go():
+        async with Rig() as rig:
+            if make is PyConnector:
+                PyConnector.OPTION_NAMES = {**PyConnector.OPTION_NAMES, "remindTimes": "remind_times"}
+            connector = make(rig, 30_000, autoDir=str(tmp_path / "auto"), **opts)
+            await connector.start()
+            client = PyClient(rig.secret, rig.relay.url)
+            try:
+                await client.start()
+                assert "remind" in client.hellos()[-1]["caps"]
+                assert await until(lambda: rig.oc.global_count() == 1, 10)
+                await client.peer.send({"t": "remind", "k": "stale", "sid": "ses_main", "grant": GRANT, "key": KEY, "url": rx.url})  # a recording: refused
+                await client.peer.send({"t": "remind", "k": client.nonce, "sid": "ses_main", "dir": "/home/u/repo", "grant": GRANT, "key": KEY, "url": rx.url})
+                await asyncio.sleep(0.2)
+                rig.oc.emit_global([_asked("/home/u/repo", ASK)])
+                assert await until(lambda: len(rx.got) >= 2, 10), "a tickle at the first mark and a reminder at the second"
+                await asyncio.sleep(0.6)
+                assert len(rx.got) == 2, "and nothing more"
+                for g in rx.got:
+                    assert g["path"] == "/space" and g["body"]["op"] == "coderemind" and g["body"]["grant"] == GRANT
+                    assert opened(g["body"]["n"]) == {"where": "test-box", "what": "npm test", "computer": "cmp_test", "session": "ses_main"}
+                    assert "npm test" not in json.dumps(g["body"]), "the text is sealed"
+            finally:
+                await client.peer.aclose()
+                await connector.stop()
+
+    try:
+        run(go())
+    finally:
+        rx.close()