witbitz-code 1.7.4__tar.gz → 1.9.0__tar.gz

{witbitz_code-1.7.4/src/witbitz_code.egg-info → witbitz_code-1.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: witbitz-code
-Version: 1.7.4
+Version: 1.9.0
 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.4 → witbitz_code-1.9.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "witbitz-code"
-version = "1.7.4"
+version = "1.9.0"
 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.4 → witbitz_code-1.9.0}/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.4"
+__version__ = "1.9.0"

witbitz_code-1.9.0/src/witbitz_code/browse.py

@@ -0,0 +1,187 @@
+"""The agent's browser on this computer — the twin of tools/browse-local-serve.mjs (2026-10-19; the owner: "I want to add the
+browsing with agent capability in local code too" → "Both stages. Default.").
+
+ON by default; `serve --no-browser` or WB_BROWSE_DISABLE=1 turns it off (and removes the agent's browser tools). The browser
+programs are JavaScript (the cloud computer's own: browse-local, the agent's CLI, the publisher), so they run with this
+computer's `node` — as the media tools do; without node the agent works without a browser. Each pairing gets a viewer key
+derived from its secret (relay.browse_key = codeRelay.js deriveBrowseKey), so the app can Watch and Take over.
+
+On Linux with the CLOUD COMPUTER'S browser installed (browsetree.py — the page's card, or `witbitz-browse-tree.mjs install`)
+it is that one instead: the image's own Chromium, KasmVNC, PulseAudio and publisher under bwrap, sealed to the FIRST
+pairing's key (the lab build seals to one). WB_BROWSE_TREE=0 keeps the laptop browser.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import re
+import shutil
+import socket
+import subprocess
+from pathlib import Path
+from typing import Any, Callable
+
+import httpx
+
+from . import browsetree, plugins
+from .relay import RELAY_URL, browse_key
+
+BROWSE_DIR = "witbitz-browse"
+PLUGIN_REL = "plugins/witbitz-browser.js"
+FILES = {  # installed path (under OpenCode's config folder) → the packaged file (tools/browse-embed.mjs writes them)
+    f"{BROWSE_DIR}/browse-local.mjs": "witbitz-browse-local.mjs",
+    f"{BROWSE_DIR}/browse-cdp.mjs": "witbitz-browse-cdp.mjs",
+    f"{BROWSE_DIR}/browse-publisher.mjs": "witbitz-browse-publisher.mjs",
+    PLUGIN_REL: "witbitz-browser.js",
+}
+
+
+def disabled(args: list[str], env: dict | None = None) -> bool:
+    env = os.environ if env is None else env
+    return "--no-browser" in args or bool(re.fullmatch(r"(?i)1|true|yes", str(env.get("WB_BROWSE_DISABLE", ""))))
+
+
+def install(config_dir: Path | None = None) -> dict[str, Path]:
+    """The browser files into OpenCode's config folder (an identical file is left alone); → their paths by file name."""
+    root = Path(config_dir) if config_dir else plugins.opencode_config_dir()
+    out = {}
+    for rel, name in FILES.items():
+        target = root / rel
+        text = plugins.packaged(name)
+        try:
+            same = target.read_text(encoding="utf-8") == text
+        except (OSError, UnicodeDecodeError):
+            same = False
+        if not same:
+            target.parent.mkdir(parents=True, exist_ok=True)
+            target.write_text(text, encoding="utf-8", newline="")
+        out[Path(rel).name] = target
+    return out
+
+
+def remove(config_dir: Path | None = None) -> None:
+    """Turned off: the agent's browser tools go, so OpenCode never offers a tool that can only fail."""
+    root = Path(config_dir) if config_dir else plugins.opencode_config_dir()
+    try:
+        (root / PLUGIN_REL).unlink()
+    except FileNotFoundError:
+        pass
+
+
+def node_major(node: str) -> int:
+    try:
+        v = subprocess.run([node, "--version"], capture_output=True, text=True, timeout=10).stdout.strip()
+        return int(v.lstrip("v").split(".")[0])
+    except (OSError, ValueError, subprocess.SubprocessError):
+        return 0
+
+
+def _free_port() -> int:
+    with socket.socket() as s:
+        s.bind(("127.0.0.1", 0))
+        return s.getsockname()[1]
+
+
+class LocalBrowser:
+    def __init__(self, proc: asyncio.subprocess.Process, ctl: int, env: dict, http: httpx.AsyncClient, tree: str = "") -> None:
+        self.proc, self.ctl, self.env, self._http, self.tree = proc, ctl, env, http, tree
+        self.last: dict | None = None
+        self._task: asyncio.Task | None = None
+
+    def probe(self) -> dict | None:
+        """The browser's last /status — synchronous: the connector's hello must never wait on it. The cloud computer's
+        browser answers as in the enclave; `local`/`cast` tell the app to watch it as this computer's, `tree` which image."""
+        if self.last is not None and self.tree:
+            return {**self.last, "local": True, "cast": True, "tree": self.tree}
+        return self.last
+
+    async def _poll(self) -> None:
+        try:
+            r = await self._http.get(f"http://127.0.0.1:{self.ctl}/status", timeout=1.5)
+            self.last = r.json() if r.status_code == 200 else None
+        except (httpx.HTTPError, ValueError):
+            self.last = None
+
+    async def _every(self) -> None:
+        while True:
+            await asyncio.sleep(2)
+            await self._poll()
+
+    async def stop(self) -> None:
+        if self._task:
+            self._task.cancel()
+        if self.proc.returncode is None:
+            try:
+                self.proc.terminate()
+                await asyncio.wait_for(self.proc.wait(), 5)
+            except (ProcessLookupError, asyncio.TimeoutError):
+                try:
+                    self.proc.kill()
+                except ProcessLookupError:
+                    pass
+        await self._http.aclose()
+
+
+async def start(pairings: list[dict], *, config_dir: Path | None = None, log: Callable[[str], Any] = print,
+                node: str | None = None) -> LocalBrowser | None:
+    """Start it; → a LocalBrowser (env for OpenCode, probe for the hello), or None when this computer has no node."""
+    node = node or shutil.which("node")
+    if not node:
+        log("witbitz-code: no node on this computer — the agent works without a browser (install Node.js 22+ to add one)")
+        return None
+    paths = await asyncio.to_thread(install, config_dir)
+    if browsetree.use_tree():
+        b = await _start_tree(node, paths, pairings, config_dir, log)
+        if b:
+            return b
+    watchable = node_major(node) >= 22  # the publisher needs a global WebSocket
+    keys = [browse_key(p["secret"]) for p in pairings if p.get("secret")] if watchable else []
+    ctl, gate = _free_port(), _free_port()
+    env = {**os.environ, "WB_BROWSE_CTL_PORT": str(ctl), "WB_BROWSE_GATE_PORT": str(gate), "WB_BROWSE_KEYS": ",".join(keys),
+           "WB_BROWSE_PUBLISHER": str(paths["browse-publisher.mjs"]), "WB_BROWSE_PARENT": str(os.getpid())}
+    proc = await asyncio.create_subprocess_exec(node, str(paths["browse-local.mjs"]), env=env, stdin=asyncio.subprocess.DEVNULL,
+                                                stdout=asyncio.subprocess.DEVNULL)
+    b = LocalBrowser(proc, ctl, {"WB_BROWSE_NODE": node, "WB_BROWSE_CDP_CLI": str(paths["browse-cdp.mjs"]),
+                                 "WB_BROWSE_CTL": f"http://127.0.0.1:{ctl}", "WB_BROWSE_CDP": f"http://127.0.0.1:{gate}"},
+                     httpx.AsyncClient())
+    for _ in range(20):  # its control port answers within a moment
+        await b._poll()
+        if b.last is not None:
+            break
+        await asyncio.sleep(0.25)
+    b._task = asyncio.ensure_future(b._every())
+    log("witbitz-code: the agent's browser is ready on this computer"
+        + (" — watch it from the Code section" if watchable else " (node is older than 22: the app cannot watch it)") + "; off: serve --no-browser")
+    return b
+
+
+async def _start_tree(node: str, paths: dict, pairings: list[dict], config_dir: Path | None, log: Callable[[str], Any]) -> LocalBrowser | None:
+    """The cloud computer's browser when it is installed here; None → the laptop browser."""
+    key = next((browse_key(p["secret"]) for p in pairings if p.get("secret")), "")
+    tree = await asyncio.to_thread(browsetree.script, config_dir)
+    st = await asyncio.to_thread(browsetree.read_status, node, tree)
+    if not key or not st.get("supported") or not st.get("installed"):
+        return None
+    proc = await asyncio.create_subprocess_exec(node, str(tree), "run", "--relay", RELAY_URL, "--parent", str(os.getpid()),
+                                                env={**os.environ, "WB_BROWSE_KEY": key}, stdin=asyncio.subprocess.DEVNULL,
+                                                stdout=asyncio.subprocess.PIPE)
+    try:
+        assert proc.stdout
+        ready = json.loads(await asyncio.wait_for(proc.stdout.readline(), 40))
+    except (ValueError, asyncio.TimeoutError, AssertionError):
+        ready = {}
+    if not ready.get("ready"):
+        log(f"witbitz-code: the cloud computer's browser did not start ({ready.get('error') or 'no answer'}) — using the laptop browser")
+        if proc.returncode is None:
+            proc.kill()
+        return None
+    env = {k: str(v) for k, v in ready.items() if k.startswith("WB_BROWSE_")}
+    env["WB_BROWSE_CDP_CLI"] = str(paths["browse-cdp.mjs"])
+    b = LocalBrowser(proc, int(env["WB_BROWSE_CTL"].rsplit(":", 1)[1]), env, httpx.AsyncClient(), tree=str(ready.get("tag") or ""))
+    await b._poll()
+    b._task = asyncio.ensure_future(b._every())
+    if st.get("current") is False:
+        log(f"witbitz-code: this release pins the cloud browser {st['pinned']['tag']} — update it on the witbitz-code page")
+    return b

witbitz_code-1.9.0/src/witbitz_code/browsetree.py

@@ -0,0 +1,117 @@
+"""THE CLOUD COMPUTER'S BROWSER ON THIS LINUX COMPUTER — the page's card and serve's choice (the owner, 2026-10-19: "why isnt
+it part of the pipx install? and why isnt it installed from the witbitz code webpage?").
+
+The program is `witbitz-browse-tree.mjs` (tools/browse-tree/cli.mjs, bundled with this release's pin by tools/browse-embed.mjs)
+run with this computer's node: `status` says what is pinned and installed, `install --json` downloads the pinned image's tree
+(~650 MB, both sha256s checked before anything is unpacked) with progress lines, `run` starts it under bwrap. Nothing is
+downloaded until the person presses Install; a release that pins a newer image shows it as an update.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import shutil
+import subprocess
+import sys
+import time
+from pathlib import Path
+from typing import Any, Callable
+
+from . import plugins
+
+SCRIPT_REL = "witbitz-browse/browse-tree.mjs"
+PACKAGED = "witbitz-browse-tree.mjs"
+
+
+def script(config_dir: Path | None = None) -> Path:
+    """The program in OpenCode's config folder, beside the other browser files (an identical file is left alone)."""
+    target = (Path(config_dir) if config_dir else plugins.opencode_config_dir()) / SCRIPT_REL
+    text = plugins.packaged(PACKAGED)
+    try:
+        same = target.read_text(encoding="utf-8") == text
+    except (OSError, UnicodeDecodeError):
+        same = False
+    if not same:
+        target.parent.mkdir(parents=True, exist_ok=True)
+        target.write_text(text, encoding="utf-8", newline="")
+    return target
+
+
+def read_status(node: str, path: Path) -> dict:
+    """`status` → {linux, needs, supported, pinned, installed, current, why}; {error} when it could not be asked."""
+    try:
+        r = subprocess.run([node, str(path), "status"], capture_output=True, text=True, timeout=20, check=False)  # noqa: S603
+        return json.loads(r.stdout.strip().splitlines()[-1])
+    except (OSError, ValueError, IndexError, subprocess.SubprocessError) as e:
+        return {"error": f"could not check ({str(e)[:80]})"}
+
+
+class Tree:
+    """The page's card: {shown, state: idle|installing|done|failed, step, pct, error, ...status}. Outside reaches are injected."""
+
+    def __init__(self, *, node: Callable[[], str | None] = lambda: shutil.which("node"),
+                 script_path: Callable[[], Path] = script, read: Callable[[str, Path], dict] = read_status,
+                 platform: str = sys.platform) -> None:
+        self._node, self._script, self._read, self._platform = node, script_path, read, platform
+        self.state, self.step, self.pct, self.error, self.tag = "idle", "", 0.0, "", ""
+        self.task: asyncio.Task | None = None
+        self._cache: tuple[float, dict] | None = None
+
+    def status(self) -> dict:
+        if not self._platform.startswith("linux"):
+            return {"shown": False}
+        live = {"state": self.state, "step": self.step, "pct": self.pct, "error": self.error, "tag": self.tag}
+        if self._cache and time.monotonic() - self._cache[0] < 15 and self.state != "installing":
+            return {**self._cache[1], **live}
+        node = self._node()
+        if not node:
+            st = {"shown": True, "supported": False, "needs": ["Node.js 22.15+"]}
+        else:
+            try:
+                st = {"shown": True, **self._read(node, self._script())}
+            except OSError as e:
+                st = {"shown": True, "error": f"could not check ({str(e)[:80]})"}
+        self._cache = (time.monotonic(), st)
+        return {**st, **live}
+
+    async def install(self) -> dict:
+        if self.task and not self.task.done():
+            return {"ok": True}
+        node = self._node()
+        if not node or not self._platform.startswith("linux"):
+            return {"ok": False, "why": "the cloud computer's browser needs Linux and Node.js"}
+        self.state, self.step, self.pct, self.error = "installing", "download", 0.0, ""
+        self.task = asyncio.ensure_future(self._install(node))
+        return {"ok": True}
+
+    async def _install(self, node: str) -> None:
+        try:
+            proc = await asyncio.create_subprocess_exec(node, str(self._script()), "install", "--json", stdin=asyncio.subprocess.DEVNULL,
+                                                        stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.DEVNULL)
+            assert proc.stdout
+            async for raw in proc.stdout:
+                try:
+                    m: dict[str, Any] = json.loads(raw)
+                except ValueError:
+                    continue
+                if m.get("error"):
+                    self.error = str(m["error"])[:300]
+                elif m.get("ok"):
+                    self.tag = str(m.get("tag") or "")
+                else:
+                    self.step, self.pct = str(m.get("step") or ""), float(m.get("pct") or 0)
+            await proc.wait()
+            if proc.returncode and not self.error:
+                self.error = f"the install stopped ({proc.returncode})"
+        except (OSError, asyncio.CancelledError) as e:
+            self.error = self.error or f"could not run it ({str(e)[:120]})"
+        finally:
+            self._cache = None
+            self.state = "failed" if self.error else "done"
+
+
+def use_tree(env: dict | None = None, platform: str = sys.platform) -> bool:
+    env = os.environ if env is None else env
+    return platform.startswith("linux") and str(env.get("WB_BROWSE_TREE", "")) != "0"

{witbitz_code-1.7.4 → witbitz_code-1.9.0}/src/witbitz_code/cli.py

@@ -26,7 +26,7 @@ import httpx
 from . import __version__
 from . import pair as pair_cmd
 from . import pairings as pp
-from . import codekeys, codetools, confidential, keys, models, plugins, policy, ports, toolsetup, uninstall as uninstall_mod, winagent, winbg, winconsole, wizard, wslstart
+from . import browse as browse_mod, codekeys, codetools, confidential, keys, models, plugins, policy, ports, toolsetup, uninstall as uninstall_mod, winagent, winbg, winconsole, wizard, wslstart
 from ._js import to_number, truthy
 from .connector import pairings_for_port, start_connector
 from .payers import SessionPayers
@@ -41,7 +41,7 @@ HELP = f"""witbitz-code {__version__} — reach OpenCode on this computer from t
                                start when I log in (Windows and WSL); it serves while it runs. --background (Windows):
                                no window — the page's Quit stops it
   pair [--name <name>]         show a QR code; scan it in Spaces (Settings → Privacy & security → Add a device)
-  serve [--port <n>] [--no-opencode]
+  serve [--port <n>] [--no-opencode] [--no-browser]
                                start OpenCode on 127.0.0.1 with your account's keys, and the connector
   status                       list this computer's pairings and their coding keys
   rotate [--account <email>]   replace the pairing secret(s) without a scan, then restart serve
@@ -217,6 +217,7 @@ async def serve(args: list[str], *, stop: Any = None, live_out: dict | None = No
     stop = stop or _Stop()
     child = None
     proxy = None
+    browser = None
     live: dict = {"connector": None}
     keys_http = httpx.AsyncClient(timeout=30)
     try:
@@ -245,6 +246,17 @@ async def serve(args: list[str], *, stop: Any = None, live_out: dict | None = No
             _err(f"witbitz-code: OpenCode is already running on 127.0.0.1:{port}, started some other way — it cannot use your account's keys.")
             _err("              Close it, then run witbitz-code serve again (it starts OpenCode itself).")
             return 1
+        # THE AGENT'S BROWSER (browse.py): ON unless --no-browser / WB_BROWSE_DISABLE=1 — started BEFORE OpenCode, whose
+        # plugin reads where it is; watched from the Code section like a cloud computer's.
+        if browse_mod.disabled(args):
+            browse_mod.remove()
+        else:
+            try:
+                browser = await browse_mod.start(pairings, log=_err)
+            except OSError as e:
+                _err(f"witbitz-code: the agent's browser could not start ({e}) — the agent works without it")
+            if browser:
+                tools_env = {**tools_env, **browser.env}
         if "--no-opencode" not in args:
             exe = wizard.find_opencode()
             if not exe:
@@ -262,7 +274,8 @@ async def serve(args: list[str], *, stop: Any = None, live_out: dict | None = No
         if child is not None:
             _err("witbitz-code: model calls are paid by each account's own coding keys; confidential models are enforced (min_privacy + verified receipts)")
         # Auto mode's reviewer asks the policy of the model proxy directly (auto_runner.REVIEW_MODELS), billed like the session.
-        connector = await start_connector(pairings, payers=payers, model_url=f"http://127.0.0.1:{proxy.port}/v1" if proxy else "")
+        connector = await start_connector(pairings, payers=payers, model_url=f"http://127.0.0.1:{proxy.port}/v1" if proxy else "",
+                                          browse_probe=browser.probe if browser else None)
         live["status"] = asyncio.ensure_future(_check_keys_every(live_keys, keys_http))
         live["connector"] = connector
         if live_out is not None:
@@ -281,6 +294,8 @@ async def serve(args: list[str], *, stop: Any = None, live_out: dict | None = No
     finally:
         if child is not None:
             await _stop_opencode(child)
+        if browser is not None:
+            await browser.stop()
         if proxy is not None:
             await proxy.close()
         await keys_http.aclose()

{witbitz_code-1.7.4 → witbitz_code-1.9.0}/src/witbitz_code/codetools.py

@@ -39,7 +39,7 @@ Tools you may expect from other setups, and what stands in for them here — do
 - todoread → todowrite returns the whole list on every write.
 - multiedit / patch → edit, one file at a time, or apply_patch where your model is offered it.
 - websearch → web_search (witbitz-media): confidential, answered by a search agent inside a hardware enclave; then webfetch a source for its full text.
-- browser → browser_open / browser_navigate / browser_snapshot / browser_click / browser_type / browser_key / browser_scroll / browser_back / browser_screenshot, when this computer offers them; act from a snapshot's numbered refs, not from a screenshot.
+- browser → browser_open / browser_navigate / browser_snapshot / browser_click / browser_type / browser_key / browser_scroll / browser_back / browser_screenshot / browser_close, when this computer offers them; close it when you are done; act from a snapshot's numbered refs, not from a screenshot.
 - lsp is here when the config enables a language server for the file type (Python: pyright); otherwise run the project's own typecheck or lint.
 """
 

{witbitz_code-1.7.4 → witbitz_code-1.9.0}/src/witbitz_code/connector.py

@@ -160,8 +160,12 @@ 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 = "", remind_times: dict | None = None) -> None:
+                 model_url: str = "", remind_times: dict | None = None,
+                 browse_probe: Callable[[], dict | None] | None = None) -> None:
         self.pairing = pairing
+        # THE AGENT'S BROWSER ON THIS COMPUTER (browse.py): its /status rides the hello; a change is announced within 2 s
+        self._browse_probe = browse_probe
+        self._browse_said = ""  # the last browse report the page was told, as JSON
         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.
         self._payers = payers
@@ -227,6 +231,8 @@ class PairingServer:
         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))
+        if self._browse_probe:
+            self._spawn(self._every(2, self._browse_changed))
         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))
         self.auto.start()
@@ -290,12 +296,27 @@ class PairingServer:
         except Exception as e:
             self._log(f"witbitz-code: {self.name} · {e}")
 
+    def _browse_report(self) -> dict | None:
+        try:
+            r = self._browse_probe() if self._browse_probe else None
+        except Exception:  # noqa: BLE001 — a probe that throws reports nothing
+            r = None
+        return r if isinstance(r, dict) else None
+
+    def _browse_changed(self) -> None:
+        now = json.dumps(self._browse_report(), sort_keys=True)
+        if now != self._browse_said and self.peer.peers >= 2:
+            self.hello()
+
     def hello(self) -> asyncio.Future | None:
         if not self.nonce:
             return None  # no hello before this socket has its nonce
+        browse = self._browse_report()
+        self._browse_said = json.dumps(browse, sort_keys=True)
         # 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", "remind"], "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(),
+                               **({"browse": browse} if browse else {})})
 
     def _auth(self) -> dict:
         pw = self.pairing.get("password") or read_env_password(Path(self.pairing["envFile"]) if self.pairing.get("envFile") else None)
@@ -941,7 +962,8 @@ 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 = "", remind_times: dict | None = None) -> Connector:
+                          model_url: str = "", remind_times: dict | None = None,
+                          browse_probe: Callable[[], dict | None] | 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()
@@ -956,7 +978,8 @@ 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, remind_times=remind_times)
+                          notes_root=notes_root, notes_plugin_path=notes_plugin_path, payers=payers, model_url=model_url, remind_times=remind_times,
+                          browse_probe=browse_probe)
         await s.start()
         servers.append(s)
     return Connector(servers, client, payers)

{witbitz_code-1.7.4 → witbitz_code-1.9.0}/src/witbitz_code/devicelink.py

@@ -116,6 +116,9 @@ def read_link_payload(p: Any) -> dict | None:
             anchor = {"method": a["method"], "email": a["email"]}
             if isinstance(token, str) and token:
                 anchor["token"] = token
+            kp = a.get("kp")
+            if isinstance(kp, dict) and truthy(kp.get("priv")) and truthy(kp.get("pub")):
+                anchor["kp"] = {"priv": kp["priv"], "pub": kp["pub"]}
             if truthy(a.get("exp")):
                 anchor["exp"] = a["exp"]
     rel = p.get("rel")
@@ -128,6 +131,7 @@ def read_link_payload(p: Any) -> dict | None:
         if isinstance(rel, dict) and isinstance(rel.get("token"), str) and rel["token"] else None,
         "idx": _ptr(p.get("idx")),
         "pipes": _ptr(p.get("pipes")),
+        "msgs": _ptr(p.get("msgs")),  # the message room (deviceLink.js since b27a27d0)
         "anchor": anchor,
     }