witbitz-code 1.8.0__tar.gz → 1.9.1__tar.gz

{witbitz_code-1.8.0/src/witbitz_code.egg-info → witbitz_code-1.9.1}/PKG-INFO

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

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

{witbitz_code-1.8.0 → witbitz_code-1.9.1}/src/witbitz_code/browse.py

@@ -5,11 +5,16 @@ ON by default; `serve --no-browser` or WB_BROWSE_DISABLE=1 turns it off (and rem
 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
@@ -20,8 +25,8 @@ from typing import Any, Callable
 
 import httpx
 
-from . import plugins
-from .relay import browse_key
+from . import browsetree, plugins
+from .relay import RELAY_URL, browse_key
 
 BROWSE_DIR = "witbitz-browse"
 PLUGIN_REL = "plugins/witbitz-browser.js"
@@ -80,13 +85,16 @@ def _free_port() -> int:
 
 
 class LocalBrowser:
-    def __init__(self, proc: asyncio.subprocess.Process, ctl: int, env: dict, http: httpx.AsyncClient) -> None:
-        self.proc, self.ctl, self.env, self._http = proc, ctl, env, http
+    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 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:
@@ -124,6 +132,10 @@ async def start(pairings: list[dict], *, config_dir: Path | None = None, log: Ca
         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()
@@ -143,3 +155,33 @@ async def start(pairings: list[dict], *, config_dir: Path | None = None, log: Ca
     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.1/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.8.0 → witbitz_code-1.9.1}/src/witbitz_code/opencode_plugins/witbitz-browse-publisher.mjs

@@ -258,16 +258,28 @@ function createCast({ cdpHttp, onFrame, onState = () => {
       const sh = c.h + BARS(c.h);
       await onPage("Emulation.setDeviceMetricsOverride", { width: c.w, height: pageFull ? sh : c.h, deviceScaleFactor: c.dpr, mobile, screenWidth: c.w, screenHeight: sh });
       await onPage("Emulation.setTouchEmulationEnabled", mobile ? { enabled: true, maxTouchPoints: 5 } : { enabled: false });
-      if (desktopUA) await onPage("Emulation.setUserAgentOverride", { userAgent: mobile ? phoneUA(desktopUA) : desktopUA });
+      if (desktopUA) await onPage("Emulation.setUserAgentOverride", uaOverride(desktopUA, await realHints(), mobile));
     } else {
       await onPage("Emulation.clearDeviceMetricsOverride").catch(() => {
       });
       await onPage("Emulation.setTouchEmulationEnabled", { enabled: false }).catch(() => {
       });
-      if (desktopUA) await onPage("Emulation.setUserAgentOverride", { userAgent: desktopUA }).catch(() => {
+      if (desktopUA) await onPage("Emulation.setUserAgentOverride", uaOverride(desktopUA, await realHints(), false)).catch(() => {
       });
     }
   }
+  let hintsOf = null;
+  async function realHints() {
+    if (hintsOf) return hintsOf;
+    const r = await onPage("Runtime.evaluate", { expression: HINTS_NOW, returnByValue: true, awaitPromise: true }).catch(() => null);
+    const v = r && r.result && r.result.value;
+    if (v && Array.isArray(v.brands) && v.brands.length) hintsOf = v;
+    if (!hintsOf) {
+      const b = await send("Browser.getVersion").catch(() => null);
+      hintsOf = hintsFromVersion(b && b.product, desktopUA);
+    }
+    return hintsOf;
+  }
   async function hookFullscreen() {
     await onPage("Runtime.enable");
     await onPage("Runtime.addBinding", { name: FS_BINDING });
@@ -467,6 +479,20 @@ function norm(v) {
   return { w, h, dpr: dpr >= 1 && dpr <= 4 ? dpr : 1, mobile: !!v.mobile };
 }
 var PHONE = { w: 412, h: 915, dpr: 2, mobile: true };
+var HINTS_NOW = `(async () => { const d = navigator.userAgentData; if (!d) return null; let h = {}; try { h = await d.getHighEntropyValues(['platformVersion', 'architecture', 'bitness', 'model', 'fullVersionList', 'wow64']) } catch (e) {} return { brands: d.brands, fullVersionList: h.fullVersionList || d.brands, platform: d.platform, platformVersion: h.platformVersion || '', architecture: h.architecture || '', bitness: h.bitness || '', model: h.model || '', wow64: !!h.wow64 } })()`;
+function hintsFromVersion(product, ua = "") {
+  const full = (/\/(\d+(?:\.\d+){1,3})/.exec(String(product || "")) || [])[1];
+  if (!full) return null;
+  const major = full.split(".")[0];
+  const platform = /Windows/.test(ua) ? "Windows" : /Mac OS X/.test(ua) ? "macOS" : /CrOS/.test(ua) ? "Chrome OS" : "Linux";
+  return { brands: [{ brand: "Chromium", version: major }, { brand: "Not)A;Brand", version: "99" }], fullVersionList: [{ brand: "Chromium", version: full }, { brand: "Not)A;Brand", version: "99.0.0.0" }], platform, platformVersion: "", architecture: /arm|aarch64/i.test(ua) ? "arm" : "x86", bitness: "64", model: "", wow64: false };
+}
+function uaOverride(desktop, real, mobile) {
+  const userAgent = mobile ? phoneUA(desktop) : desktop;
+  if (!real || !Array.isArray(real.brands) || !real.brands.length) return { userAgent };
+  const meta = { brands: real.brands, fullVersionList: real.fullVersionList || real.brands, platform: real.platform || "", platformVersion: real.platformVersion || "", architecture: real.architecture || "", model: real.model || "", mobile: false, bitness: real.bitness || "", wow64: !!real.wow64 };
+  return mobile ? { userAgent, platform: "Linux armv8l", userAgentMetadata: { ...meta, platform: "Android", platformVersion: "14.0.0", architecture: "", bitness: "", model: "Pixel 8", mobile: true, wow64: false } } : { userAgent, userAgentMetadata: meta };
+}
 function phoneUA(desktop) {
   return desktop.replace(/\([^)]*\)/, "(Linux; Android 14; Pixel 8)").replace(/ Safari\//, " Mobile Safari/");
 }
@@ -476,6 +502,7 @@ var BINDING = "__wbm";
 var MAX_BATCH = 8 << 20;
 var MAX_SINCE_SNAPSHOT = 48 << 20;
 var ASSET_CACHE = 96 << 20;
+var MAX_ANSWER = 2900 << 10;
 var MAX_SIDE2 = 1600;
 var STILL_MS = 500;
 var STILL_SIDE = 480;
@@ -607,12 +634,19 @@ function createMirrors({ liveHttp, mirrorHttp, rrwebUmd, onFrame, log: log2 = ()
       for (const h of c.handlers) h(m);
     };
     ws.onclose = () => {
+      c.closed = true;
+      log2("mirror: the CDP connection to", http, "closed");
       for (const p of c.pending.values()) p.reject(new Error("cdp: closed"));
       c.pending.clear();
     };
     return c;
   }
   async function attachLive() {
+    if (live && live.closed) {
+      live = null;
+      liveSid = null;
+      liveTargetId = null;
+    }
     const t = liveTarget();
     if (!t || t === liveTargetId) return;
     if (!live) {
@@ -698,8 +732,14 @@ function createMirrors({ liveHttp, mirrorHttp, rrwebUmd, onFrame, log: log2 = ()
       body: body ? Buffer.from(body).toString("base64") : ""
     }, tab.sid).catch(() => {
     });
+    const tooBig = (b) => b && Buffer.byteLength(b) > MAX_ANSWER;
+    const send = (status, headers, body) => tooBig(body) ? (tab.refused++, log2("mirror: not sent,", Math.round(Buffer.byteLength(body) / 1024), "KB \u2014", url.slice(0, 100)), done(404, {}, "")) : done(status, headers, body);
     if (url === "http://mirror.invalid/") return done(200, { "content-type": "text/html; charset=utf-8" }, shell);
     if (p.request.method !== "GET" || !/^https?:\/\//.test(url)) return done(404, {}, "");
+    if (p.resourceType === "Media") {
+      tab.refused++;
+      return done(404, {}, "");
+    }
     if (p.resourceType === "Document") {
       let host = "";
       try {
@@ -714,14 +754,14 @@ function createMirrors({ liveHttp, mirrorHttp, rrwebUmd, onFrame, log: log2 = ()
       try {
         const r = await live.send("Network.getResponseBody", { requestId: known.requestId }, liveSid);
         tab.served++;
-        return done(known.status || 200, { "content-type": known.mime || "application/octet-stream" }, r.base64Encoded ? Buffer.from(r.body, "base64") : r.body);
+        return send(known.status || 200, { "content-type": known.mime || "application/octet-stream" }, r.base64Encoded ? Buffer.from(r.body, "base64") : r.body);
       } catch {
       }
     }
     if (assets.has(url)) {
       tab.served++;
       const a = assets.get(url);
-      return done(a.status, a.headers, a.body);
+      return send(a.status, a.headers, a.body);
     }
     if (!STATIC.has(p.resourceType) || !liveSid) {
       tab.refused++;
@@ -730,7 +770,7 @@ function createMirrors({ liveHttp, mirrorHttp, rrwebUmd, onFrame, log: log2 = ()
     try {
       const a = await loadCredentialless(url);
       tab.loaded++;
-      return done(a.status, a.headers, a.body);
+      return send(a.status, a.headers, a.body);
     } catch (e) {
       tab.refused++;
       log2("mirror: could not load", url.slice(0, 100), "\u2014", String(e.message || e).slice(0, 120));
@@ -816,7 +856,7 @@ function createMirrors({ liveHttp, mirrorHttp, rrwebUmd, onFrame, log: log2 = ()
     });
   }
   async function open2(stream, shape) {
-    if (!mirror) {
+    if (!mirror || mirror.closed) {
       mirror = await connect(mirrorHttp);
       mirror.handlers.push(onMirror);
     }
@@ -881,6 +921,10 @@ function createMirrors({ liveHttp, mirrorHttp, rrwebUmd, onFrame, log: log2 = ()
     /** Make the set of mirrors equal `wanted` (stream → shape). Opens, reshapes and closes as needed. */
     async set(wanted) {
       await attachLive();
+      if (mirror && mirror.closed) {
+        mirror = null;
+        tabs.clear();
+      }
       for (const [stream] of tabs) if (!wanted.has(stream)) await close(stream);
       for (const [stream, shape] of wanted) {
         const tab = tabs.get(stream);
@@ -945,6 +989,7 @@ var tellControl = async (path, body) => {
   }
 };
 var said = null;
+var holderVid = null;
 var tellTheViewerWhoHasTheControls = async (why) => {
   let st = null;
   try {
@@ -954,16 +999,17 @@ var tellTheViewerWhoHasTheControls = async (why) => {
   }
   held = !!st.takeover;
   if (!held && cast && cast.incognito && cast.incognito()) closeIncognito("the controls lapsed");
+  if (!held) holderVid = null;
   if (!held && cast && cast.controller()) {
     for (const v of castViewers.values()) v.driving = false;
     cast.setController(null).then(assign).catch(() => {
     });
   }
-  const now = JSON.stringify({ on: !!st.takeover, web: !!st.web });
+  const now = JSON.stringify({ on: !!st.takeover, web: !!st.web, holder: holderVid });
   if (why === "poll" && now === said) return;
   said = now;
   if (relay && relay.readyState === 1) {
-    relay.send(await sealCtl(key, { wb: "takeover", on: !!st.takeover, web: !!st.web, audio: !!PULSE, ack: true, cast: !!CDP, site: siteNow(), incognito: !!(cast && cast.incognito && cast.incognito()) }));
+    relay.send(await sealCtl(key, { wb: "takeover", on: !!st.takeover, web: !!st.web, ...st.takeover && holderVid ? { holder: holderVid } : {}, audio: !!PULSE, ack: true, cast: !!CDP, site: siteNow(), incognito: !!(cast && cast.incognito && cast.incognito()) }));
   }
   log(
     why === "poll" ? "the state changed \u2014" : "a viewer arrived \u2014",
@@ -1223,7 +1269,22 @@ async function assignNow() {
     } catch {
     }
   }
-  if (mirrors) await mirrors.set(wanted);
+  if (!mirrors) return;
+  try {
+    await mirrors.set(wanted);
+  } catch (e) {
+    const why = "mirror could not open: " + String(e.message || e).slice(0, 80);
+    for (const [vid, s] of assigned) {
+      if (!wanted.has(s)) continue;
+      assigned.set(vid, "live");
+      if (relay && relay.readyState === 1) relay.send(await sealCtl(key, { wb: "stream", vid, stream: "live", why }));
+    }
+    const l = cast && cast.last();
+    if (l) outOrder(async () => {
+      if (relay && relay.readyState === 1) relay.send(await seal(key, KIND_FRAME, packFrame(l.header, l.jpeg)));
+    });
+    throw e;
+  }
 }
 async function startCast() {
   const c = ensureCast();
@@ -1327,12 +1388,13 @@ function connectRelay() {
           if (!c.on) await closeIncognito("the controls were given back");
           await tellControl("/takeover", { on: !!c.on });
           held = !!c.on;
+          holderVid = c.on && typeof c.vid === "string" ? c.vid.slice(0, 64) : null;
           log("take-over", c.on ? "ON \u2014 the agent's CDP session is being closed" : "released");
           if (cast) await cast.setController(c.on ? norm(c.view) || largestView() : null).catch(() => {
           });
           for (const [vid, v] of castViewers) v.driving = !!c.on && vid === c.vid;
           if (cast) assign();
-          if (relay && relay.readyState === 1) relay.send(await sealCtl(key, { wb: "takeover", on: !!c.on, audio: !!PULSE, ack: true, cast: !!cast, site: siteNow(), incognito: !!(cast && cast.incognito && cast.incognito()), close: true }));
+          if (relay && relay.readyState === 1) relay.send(await sealCtl(key, { wb: "takeover", on: !!c.on, ...holderVid ? { holder: holderVid } : {}, audio: !!PULSE, ack: true, cast: !!cast, site: siteNow(), incognito: !!(cast && cast.incognito && cast.incognito()), close: true }));
         } else if (c.wb === "incognito" && cast) {
           if (c.on && !held) {
             log("incognito: refused \u2014 nobody holds the controls");
@@ -1357,12 +1419,13 @@ function connectRelay() {
           if (relay && relay.readyState === 1) relay.send(await sealCtl(key, { wb: "site", mode }));
         } else if (c.wb === "hello" && c.cast && typeof c.vid === "string" && CDP) {
           const known = castViewers.has(c.vid);
-          castViewers.set(c.vid.slice(0, 64), { view: norm(c.view), at: Date.now(), driving: !!(held && c.driving) });
+          const mine = held && c.driving && (!holderVid || c.vid.slice(0, 64) === holderVid);
+          castViewers.set(c.vid.slice(0, 64), { view: norm(c.view), at: Date.now(), driving: !!mine });
           if (castViewers.size > 8) castViewers.delete(castViewers.keys().next().value);
           if (!known) log("cast: a viewer said hello \u2014", JSON.stringify(norm(c.view)));
           if (relay && relay.readyState === 1) relay.send(await sealCtl(key, { wb: "cast", on: true, close: true }));
           await startCast();
-          if (held && cast && c.driving) await cast.setController(norm(c.view)).catch(() => {
+          if (mine && cast) await cast.setController(norm(c.view)).catch(() => {
           });
           assign();
         } else if (c.wb === "in" && cast) {