witbitz-code 1.11.0__tar.gz → 1.13.0__tar.gz

{witbitz_code-1.11.0/src/witbitz_code.egg-info → witbitz_code-1.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: witbitz-code
-Version: 1.11.0
+Version: 1.13.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.11.0 → witbitz_code-1.13.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "witbitz-code"
-version = "1.11.0"
+version = "1.13.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.11.0 → witbitz_code-1.13.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.11.0"
+__version__ = "1.13.0"

{witbitz_code-1.11.0 → witbitz_code-1.13.0}/src/witbitz_code/browse.py

@@ -97,6 +97,18 @@ class LocalBrowser:
             return {**self.last, "local": True, "cast": True, "tree": self.tree}
         return self.last
 
+    async def set_private(self, on: bool) -> bool:
+        """Private browsing on/off (the app's switch, through the connector): browse-local.mjs keeps it and wipes the profile.
+        The cloud computer's browser (a tree) takes it from its own bundle, not from here."""
+        if self.tree:
+            return False
+        try:
+            r = await self._http.post(f"http://127.0.0.1:{self.ctl}/private", json={"on": bool(on)}, timeout=5)
+            self.last = r.json() if r.status_code == 200 else self.last
+        except (httpx.HTTPError, ValueError):
+            await self._poll()
+        return bool(self.last and self.last.get("private") is bool(on))
+
     async def _poll(self) -> None:
         try:
             r = await self._http.get(f"http://127.0.0.1:{self.ctl}/status", timeout=1.5)

{witbitz_code-1.11.0 → witbitz_code-1.13.0}/src/witbitz_code/cli.py

@@ -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] [--no-browser]
+  serve [--port <n>] [--no-opencode] [--no-browser] [--private-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
@@ -272,6 +272,8 @@ async def serve(args: list[str], *, stop: Any = None, live_out: dict | None = No
         if browse_mod.disabled(args):
             browse_mod.remove()
         else:
+            if "--private-browser" in args:
+                os.environ["WB_BROWSE_PRIVATE"] = "1"  # private browsing on (browse-local.mjs keeps it; the app's switch turns it off)
             try:
                 browser = await browse_mod.start(pairings, log=_err, profile=(store / "browse-profile") if store is not None else None)
             except OSError as e:
@@ -296,7 +298,8 @@ async def serve(args: list[str], *, stop: Any = None, live_out: dict | None = No
             _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 "",
-                                          browse_probe=browser.probe if browser else None)
+                                          browse_probe=browser.probe if browser else None,
+                                          browse_private=browser.set_private 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:

{witbitz_code-1.11.0 → witbitz_code-1.13.0}/src/witbitz_code/codekeys.py

@@ -26,6 +26,7 @@ from cryptography.hazmat.primitives.asymmetric import ec, ed25519
 from cryptography.hazmat.primitives.ciphers.aead import AESGCM
 from cryptography.hazmat.primitives.kdf.hkdf import HKDF
 
+from . import app as app_mod
 from . import pairings as pp
 
 API = "https://api.witbitz.chat/v1/spaces/code-keys"
@@ -194,7 +195,7 @@ def sign_in_left_s(token: str, now: float | None = None) -> float:
 
 
 async def mint(client: httpx.AsyncClient, *, id_token: str, account: str, computer_id: str, name: str,
-               ident: dict | None = None) -> dict:
+               ident: dict | None = None, app: str | None = None) -> dict:
     """Ask the account for this computer's keys → the entry to save. Raises CodeKeyRefusal with a sentence."""
     if not id_token:
         raise CodeKeyRefusal("not_signed_in", REFUSALS["not_signed_in"])
@@ -202,19 +203,28 @@ async def mint(client: httpx.AsyncClient, *, id_token: str, account: str, comput
         raise CodeKeyRefusal("signin_stale", REFUSALS["signin_stale"])
     ident = ident or new_identity()
     try:
+        # `app`: the Spaces app this pairing belongs to — each app keeps its own computers and allowance (the owner,
+        # 2026-10-23: "they should be completely separate"); the server files the keys under that app's tenant.
         r = await client.post(api_base(), json={"idToken": id_token, "computerId": computer_id, "name": name,
-                                                "sealPub": seal_pub(ident), "signPub": sign_pub(ident)}, timeout=30)
+                                                "sealPub": seal_pub(ident), "signPub": sign_pub(ident), "app": app or app_mod.name()}, timeout=30)
     except httpx.HTTPError as e:
         raise CodeKeyRefusal("unreachable", f"could not reach Witbitz to get this computer's keys ({str(e)[:80]})") from e
     if r.status_code != 200:
         raise _refusal(r, account)
     d = (r.json() or {}).get("data") or {}
-    entry = {"account": account, "computerId": computer_id, "name": name, "keyId": d.get("keyId"), "tenantId": d.get("tenantId"),
-             "userId": d.get("userId"), "kid": d.get("kid"), **ident, "caps": d.get("caps") or {}, "at": int(time.time() * 1000)}
+    entry = {"account": account, "computerId": computer_id, "name": name, **ident, "app": app or app_mod.name(), "at": int(time.time() * 1000)}
+    return _take(entry, d)
+
+
+def _take(entry: dict, d: dict) -> dict:
+    """A minted pair (a pairing, or a move to the computer's own app) into `entry`: its ids, caps and keys opened with the
+    computer's own identity. Raises CodeKeyRefusal when they cannot be opened."""
+    entry.update({"keyId": d.get("keyId"), "tenantId": d.get("tenantId"), "userId": d.get("userId"), "kid": d.get("kid"), "caps": d.get("caps") or {}})
+    entry.pop("tinfoil", None)
     sealed = d.get("sealed") or {}
     for provider in PROVIDERS:
         if sealed.get(provider):
-            secret = open_sealed(sealed[provider], ident, aad(entry["tenantId"], entry["userId"], entry["kid"], provider))
+            secret = open_sealed(sealed[provider], entry, aad(entry["tenantId"], entry["userId"], entry["kid"], provider))
             if secret is None:
                 raise CodeKeyRefusal("unsealable", "the keys Witbitz sent could not be opened on this computer — pair again")
             entry[provider] = secret
@@ -223,6 +233,18 @@ async def mint(client: httpx.AsyncClient, *, id_token: str, account: str, comput
     return entry
 
 
+def app_of(entry: dict) -> str:
+    """The Spaces app these keys are for: recorded at the mint since 2026-10-23; before that, the app of the pairing they
+    belong to (its `origin`), else this install's."""
+    if entry.get("app") in (app_mod.REGULAR, app_mod.VAULTED):
+        return entry["app"]
+    try:
+        p = next((x for x in pp.read_pairings()["pairings"] if x.get("computerId") == entry.get("computerId")), None)
+    except Exception:  # noqa: BLE001 — a reading; the install's own app is the answer then
+        p = None
+    return app_mod.of_origin(p.get("origin")) if p and p.get("origin") else app_mod.name()
+
+
 def _server_time(r: httpx.Response) -> float | None:
     try:
         return parsedate_to_datetime(r.headers.get("date") or "").timestamp()
@@ -230,14 +252,25 @@ def _server_time(r: httpx.Response) -> float | None:
         return None
 
 
+def _status_body(entry: dict) -> dict:
+    """The status call, naming the app these keys are for and signing a move there ('move:<app>'): a computer the server has
+    under the other app's tenant moves to its own (every computer paired before 2026-10-23 was under the hosted app's)."""
+    b = signed_body("status", entry)
+    a = app_of(entry)
+    b["app"] = a
+    b["moveSig"] = _b64u(_sign_key(entry).sign(signed_message("move:" + a, entry["keyId"], b["ts"]).encode()))
+    return b
+
+
 async def _signed_post(client: httpx.AsyncClient, path: str, op: str, entry: dict, timeout: float = 10) -> httpx.Response:
     """A signed call; refused while this computer's clock is off the server's, it is signed again to the server's time."""
-    r = await client.post(api_base() + path, json=signed_body(op, entry), timeout=timeout)
+    body = (lambda: _status_body(entry)) if op == "status" else (lambda: signed_body(op, entry))
+    r = await client.post(api_base() + path, json=body(), timeout=timeout)
     if r.status_code == 401:
         server = _server_time(r)
         if server is not None and abs(server - _now()) > SKEW_FIX_S:
             _clock["skew"] = server - time.time()
-            r = await client.post(api_base() + path, json=signed_body(op, entry), timeout=timeout)
+            r = await client.post(api_base() + path, json=body(), timeout=timeout)
     return r
 
 
@@ -259,6 +292,19 @@ async def status(client: httpx.AsyncClient, entry: dict) -> dict:
     if r.status_code != 200:
         return {"live": None, "why": _why(r)}  # unknown — keep going as before, and say why
     d = (r.json() or {}).get("data") or {}
+    moved = d.get("moved")
+    if isinstance(moved, dict) and moved.get("keyId"):
+        # MOVED TO ITS OWN APP: the server retired the old pair, so the new one is taken and SAVED here, whoever asked
+        # (serve's check, the page, `pair --status`) — keys left unsaved would be keys this computer no longer has.
+        try:
+            _take(entry, moved)
+            entry["app"] = app_of(entry)
+            save(entry)
+            d["changed"] = False  # saved already
+            d["movedTo"] = entry["app"]
+        except CodeKeyRefusal as e:
+            return {"live": None, "why": str(e)}
+        return d
     tf = (d.get("sealed") or {}).get("tinfoil")
     if tf:
         secret = open_sealed(tf, entry, aad(entry["tenantId"], entry["userId"], entry["kid"], "tinfoil"))
@@ -354,6 +400,8 @@ class LiveKeys:
                     say(f'witbitz-code: coding for {e.get("account")} is paused by Witbitz')
                 self.refuse[cid] = PAUSED_TEXT
             elif st.get("live") is True:
+                if st.get("movedTo"):
+                    say(f'witbitz-code: "{e.get("name")}" → {e.get("account")} now codes under the {app_mod.label(st["movedTo"])}\'s own allowance')
                 if self.refuse.pop(cid, None):
                     say(f'witbitz-code: coding for {e.get("account")} is back on')
                 if st.get("changed"):

{witbitz_code-1.11.0 → witbitz_code-1.13.0}/src/witbitz_code/connector.py

@@ -22,7 +22,7 @@ import re
 import sys
 import time
 import urllib.parse
-from collections.abc import Callable
+from collections.abc import Awaitable, Callable
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any
@@ -162,8 +162,10 @@ class PairingServer:
                  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,
-                 browse_probe: Callable[[], dict | None] | None = None) -> None:
+                 browse_probe: Callable[[], dict | None] | None = None,
+                 browse_private: Callable[[bool], Awaitable[bool]] | None = None) -> None:
         self.pairing = pairing
+        self._browse_private = browse_private  # private browsing on/off (browse.py LocalBrowser.set_private)
         # 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
@@ -355,6 +357,12 @@ class PairingServer:
             # Which suggested tools this computer has (spaces/public/codeTools.js) — a PATH lookup, nonce-checked like a request.
             if current:
                 await self.peer.send({"t": "tools", **probe_tools()})
+        elif t == "browse":
+            # PRIVATE BROWSING for the agent's browser on this computer (browse-local.mjs wipes its profile at every open and
+            # close). Nonce-checked like a request; only a browser that says `canPrivate` is offered the switch by the page.
+            if current and self._browse_private and isinstance(m.get("private"), bool):
+                await self._browse_private(m["private"])
+                self.hello()
         elif t == "models":
             # The models the control plane offers as CONFIDENTIAL today. Added to what this release knows, never subtracted
             # (models.add_confidential), so a model added after this release still gets the floor + receipt — and no list from
@@ -964,7 +972,8 @@ async def start_connector(pairings: list[dict], *, flush_ms: float = 120, log: C
                           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,
-                          browse_probe: Callable[[], dict | None] | None = None) -> Connector:
+                          browse_probe: Callable[[], dict | None] | None = None,
+                          browse_private: Callable[[bool], Awaitable[bool]] | 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()
@@ -980,7 +989,7 @@ async def start_connector(pairings: list[dict], *, flush_ms: float = 120, log: C
                           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,
-                          browse_probe=browse_probe)
+                          browse_probe=browse_probe, browse_private=browse_private)
         await s.start()
         servers.append(s)
     return Connector(servers, client, payers)

{witbitz_code-1.11.0 → witbitz_code-1.13.0}/src/witbitz_code/devicelink.py

@@ -26,6 +26,8 @@ from ._js import b64u, truthy, unb64u_loose
 
 LINK_PREFIX = "wbzlink1:"
 _LINK_INFO = b"witbitz-device-link-v1"
+_ACK_INFO = b"witbitz-device-link-ack-v1"  # the report back to the giver (⇄ spaces/public/deviceLink.js ACK_INFO)
+_WHY_MAX = 300
 _BACKUP_SALT = b"witbitz-spaces-backup-v1"
 
 
@@ -52,11 +54,12 @@ def _import_pub(b64: Any) -> ec.EllipticCurvePublicKey:
         raise ValueError("bad_point") from e
 
 
-def _shared_key(priv: ec.EllipticCurvePrivateKey, pub: ec.EllipticCurvePublicKey, ref: Any) -> AESGCM:
-    """Both sides derive the same AES-GCM key from the shared point, bound to the ref so a blob can't be replayed at another."""
+def _shared_key(priv: ec.EllipticCurvePrivateKey, pub: ec.EllipticCurvePublicKey, ref: Any, info: bytes = _LINK_INFO) -> AESGCM:
+    """Both sides derive the same AES-GCM key from the shared point, bound to the ref so a blob can't be replayed at another.
+    `info` names its use: the reply, or the report back to the giver (_ACK_INFO)."""
     bits = priv.exchange(ec.ECDH(), pub)
     salt = _js.js_string(ref).encode("utf-8")
-    return AESGCM(HKDF(algorithm=hashes.SHA256(), length=32, salt=salt, info=_LINK_INFO).derive(bits))
+    return AESGCM(HKDF(algorithm=hashes.SHA256(), length=32, salt=salt, info=info).derive(bits))
 
 
 def new_link_challenge() -> LinkChallenge:
@@ -90,6 +93,18 @@ def seal_to_challenge(challenge: dict, payload: Any) -> dict:
     return {"ref": challenge["ref"], "epk": _export_pub(mine.public_key()), "blob": b64u(iv + ct)}
 
 
+def seal_link_ack(priv: ec.EllipticCurvePrivateKey, reply: dict, ok: bool, why: str = "") -> dict:
+    """THE REPORT BACK TO THE GIVER (the owner, 2026-10-23: the phone said "Sent ✓" while this computer refused the other app's
+    code): {ok, why} sealed under a second key from the same exchange → {ref, ack} to POST to /api/link. Only the phone that
+    sealed the reply can open it (deviceLink.js openLinkAck)."""
+    key = _shared_key(priv, _import_pub(reply.get("epk")), reply.get("ref"), _ACK_INFO)
+    body: dict = {"v": 1, "ok": bool(ok)}
+    if why:
+        body["why"] = str(why)[:_WHY_MAX]
+    iv = os.urandom(12)
+    return {"ref": reply.get("ref"), "ack": b64u(iv + key.encrypt(iv, _js.stringify(body).encode("utf-8"), None))}
+
+
 def open_link_reply(priv: ec.EllipticCurvePrivateKey, reply: dict) -> Any:
     """Open what the ref handed back. Raises on anything that isn't ours and intact."""
     key = _shared_key(priv, _import_pub(reply.get("epk")), reply.get("ref"))

{witbitz_code-1.11.0 → witbitz_code-1.13.0}/src/witbitz_code/link.py

@@ -16,7 +16,7 @@ import os
 import re
 import sys
 import time
-from collections.abc import Callable
+from collections.abc import Awaitable, Callable
 from pathlib import Path
 from typing import Any
 
@@ -142,6 +142,22 @@ async def link_node(*, life_ms: float | None = None, poll_s: float = POLL_S, ori
             await client.aclose()
 
 
+def _reporter(priv, reply: dict, origin: str) -> Callable[[bool, str], Awaitable[None]]:
+    """The report back to the giving phone (devicelink.seal_link_ack): best effort, on a client of its own — the link's is
+    closed by the time pairing ends. A phone that hears nothing says this computer has the keys."""
+    async def report(ok: bool, why: str = "") -> None:
+        client = None
+        try:
+            client = net.new_client()
+            await net.make_post_json(client)(f"{origin}/api/link", devicelink.seal_link_ack(priv, reply, ok, why))
+        except Exception:  # noqa: BLE001 — the pairing's own outcome stands either way
+            pass
+        finally:
+            if client is not None:
+                await client.aclose()
+    return report
+
+
 async def _link(life_ms, poll_s, origins, get_json, post_json, challenge, svg_path, out, err) -> dict | None:
     ch = challenge or devicelink.new_link_challenge()
     out(f"witbitz-code: pairing this computer with your account · polling {', '.join(origins)}\n")
@@ -181,10 +197,16 @@ async def _link(life_ms, poll_s, origins, get_json, post_json, challenge, svg_pa
         if not pay:
             err("witbitz-code: a reply arrived but did not open — start again on both devices.")
             return None
+        reply = {"ref": ch.ref, "epk": r.get("epk")}
+        report = _reporter(ch.priv, reply, found)
         account = account_from_payload(pay)
         if not account:
             err("witbitz-code: the reply carried no account key.")
+            await report(False, "the reply carried no account key.")
             return None
+        # HOW IT WENT, for the phone that sent it (the owner, 2026-10-23: it said "Sent ✓" while this computer refused the
+        # code): pair.py calls it with the outcome. Never saved — upsert_pairing takes named fields only.
+        account["_report"] = report
         # THE APP IT CAME FROM (the owner, 2026-10-22: a second account paired from the hosted app → "computers read refused
         # (404: not_found)"): the relay that held the reply is that app's own address, and its rooms answer only their own app
         # since 2026-10-18 — so this account's calls speak as it (pairings.json `origin`, net.call_for).

{witbitz_code-1.11.0 → witbitz_code-1.13.0}/src/witbitz_code/opencode_plugins/witbitz-browse-local.mjs

@@ -16,6 +16,9 @@
 //   owner    :WB_BROWSE_OWNER_PORT (any free port by default) — the same pass-through for the PUBLISHER (the screencast and
 //            the owner's input), never closed by a take-over: the cloud computer's owner door (vm/cdpmux.go :9225)
 //   control  POST /takeover {on, gone}  on: every connection through the gate is dropped and new ones refused until it is off
+//            POST /private {on}       PRIVATE BROWSING: the profile (cookies, logins, history) is wiped before Chromium starts,
+//                                     when it stops, and when this starts — so nothing outlives a session. Kept in a file beside
+//                                     the profile (<profile>.private), so it survives a restart; WB_BROWSE_PRIVATE=1 turns it on.
 //
 // WATCH AND TAKE OVER FROM THE APP (2026-10-19; the owner: "Both stages. Default."): with WB_BROWSE_KEYS (one base64 key per
 // pairing — codeRelay.js deriveBrowseKey(secret)) and WB_BROWSE_PUBLISHER (the cloud computer's vm/browse-publisher.mjs, run
@@ -30,8 +33,8 @@
 import { spawn } from 'node:child_process'
 import { createServer, request as httpRequest } from 'node:http'
 import { connect } from 'node:net'
-import { existsSync, readdirSync, mkdirSync } from 'node:fs'
-import { join } from 'node:path'
+import { existsSync, readdirSync, mkdirSync, rmSync, writeFileSync } from 'node:fs'
+import { join, resolve, parse } from 'node:path'
 import { homedir, platform } from 'node:os'
 
 const CTL_PORT = Number(process.env.WB_BROWSE_CTL_PORT || 9224)
@@ -75,12 +78,28 @@ export function wantHeaded (env = process.env) {
 }
 
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms))
+
+/** PRIVATE BROWSING's wipe: the dedicated profile goes, whole. Refuses a path that is a filesystem root or the home folder —
+ *  WB_BROWSE_PROFILE is the person's to set, and a wipe must never be able to reach their own files. Chromium on Windows can
+ *  hold a file for a moment after it exits, hence the retries. → true when nothing is left. */
+export function wipeProfile (profile, { home = homedir(), rm = rmSync, exists = existsSync } = {}) {
+  const p = resolve(String(profile || ''))
+  if (!profile || p === parse(p).root || p === resolve(home)) return false
+  try { rm(p, { recursive: true, force: true, maxRetries: 5, retryDelay: 200 }) } catch { /* reported below */ }
+  return !exists(p)
+}
 const getJson = (url) => fetch(url, { signal: AbortSignal.timeout(2000) }).then((r) => (r.ok ? r.json() : null)).catch(() => null)
 
 /** The gate: a small object with start()/stop() around one Chromium, exported so a test can drive it on free ports. */
 export function makeGate ({ ctlPort = CTL_PORT, gatePort = GATE_PORT, ownerPort = OWNER_PORT, profile = PROFILE, chrome = findChromium(), headed = wantHeaded(), startMs = START_MS, keys = KEYS, publisher = PUBLISHER, node = process.execPath, relay = process.env.WB_BROWSE_RELAY || '' } = {}) {
   let child = null, realPort = 0, starting = null, lastErr = '', bound = gatePort // bound: the gate's ACTUAL port once listening (gatePort may be 0 = any)
   let takeover = false
+  const privFile = profile + '.private'
+  let priv = existsSync(privFile)
+  if (/^(1|true|yes)$/i.test(String(process.env.WB_BROWSE_PRIVATE || ''))) priv = true
+  const keepPrivate = () => { try { if (priv) writeFileSync(privFile, '1\n'); else rmSync(privFile, { force: true }) } catch (e) { log('private browsing: could not keep the setting —', e.message) } }
+  keepPrivate()
+  const forget = (why) => { if (!priv) return; const ok = wipeProfile(profile); log(ok ? `private browsing: the profile is wiped (${why})` : `private browsing: THE PROFILE WAS NOT WIPED (${why})`) }
   const gateSockets = new Set() // the agent's live CDP connections — what a take-over drops
   const pubs = new Map() // key → { proc, stopped } — one publisher per pairing key
   const running = () => !!(child && child.exitCode === null && realPort)
@@ -90,6 +109,7 @@ export function makeGate ({ ctlPort = CTL_PORT, gatePort = GATE_PORT, ownerPort
     if (starting) return starting
     starting = (async () => {
       if (!chrome) throw new Error('no Chromium on this computer — install Google Chrome or Chromium, or set WB_BROWSE_CHROME to one')
+      forget('before it opens')
       mkdirSync(profile, { recursive: true })
       // --remote-debugging-port=0 lets Chromium pick a free port; it prints "DevToolsActivePort" into the profile dir and
       // "DevTools listening on ws://…" on stderr — the stderr line is the quicker of the two to read.
@@ -103,7 +123,7 @@ export function makeGate ({ ctlPort = CTL_PORT, gatePort = GATE_PORT, ownerPort
       child = p; realPort = 0; lastErr = ''
       let err = ''
       p.stderr.on('data', (d) => { err += String(d); const m = /DevTools listening on ws:\/\/127\.0\.0\.1:(\d+)\//.exec(err); if (m && !realPort) realPort = Number(m[1]) })
-      p.on('exit', (code, sig) => { if (child === p) { child = null; realPort = 0; log(`chromium exited (${sig || code})`) } })
+      p.on('exit', (code, sig) => { if (child === p) { child = null; realPort = 0; log(`chromium exited (${sig || code})`); forget('it closed') } })
       const t0 = Date.now()
       while (!realPort && child === p && Date.now() - t0 < startMs) await sleep(100)
       if (child !== p) throw new Error('Chromium exited before it was ready: ' + (err.trim().split('\n').pop() || '').slice(0, 160))
@@ -114,7 +134,7 @@ export function makeGate ({ ctlPort = CTL_PORT, gatePort = GATE_PORT, ownerPort
     })().catch((e) => { lastErr = String(e && e.message ? e.message : e); throw e }).finally(() => { starting = null })
     return starting
   }
-  const report = () => ({ offered: true, running: running(), takeover, web: true, local: true, headed, ...(pubs.size ? { cast: true } : {}), ...(lastErr ? { lastError: lastErr } : {}) })
+  const report = () => ({ offered: true, running: running(), takeover, web: true, local: true, headed, private: priv, canPrivate: true, ...(pubs.size ? { cast: true } : {}), ...(lastErr ? { lastError: lastErr } : {}) })
   const readBody = (req) => new Promise((resolve) => { let b = ''; req.setEncoding('utf8'); req.on('data', (d) => { if (b.length < 4096) b += d }); req.on('end', () => { try { resolve(JSON.parse(b || '{}')) } catch { resolve({}) } }); req.on('error', () => resolve({})) })
 
   const ctl = createServer(async (req, res) => {
@@ -124,6 +144,15 @@ export function makeGate ({ ctlPort = CTL_PORT, gatePort = GATE_PORT, ownerPort
       return
     }
     if (req.url === '/status') return res.end(JSON.stringify(report()))
+    // PRIVATE BROWSING on/off (the app's switch on this computer's card, through the connector). Turned on while no browser
+    // runs, what the last session left is wiped now; while one runs, at its close.
+    if (req.method === 'POST' && req.url === '/private') {
+      const b = await readBody(req)
+      priv = !!b.on; keepPrivate()
+      log('private browsing', priv ? 'ON' : 'off')
+      if (priv && !running() && !starting) forget('turned on')
+      return res.end(JSON.stringify({ ok: true, ...report() }))
+    }
     if (req.method === 'POST' && req.url === '/close') { try { child && child.kill() } catch { /* */ } takeover = false; return res.end(JSON.stringify({ ok: true })) }
     // THE TAKE-OVER (the publisher asks, on the owner's sealed word — browse-publisher.mjs): on → the agent's connections go
     // and stay gone until it is off; `gone` = the last viewer left, which ends it too (the cloud computer's rule).
@@ -193,6 +222,7 @@ export function makeGate ({ ctlPort = CTL_PORT, gatePort = GATE_PORT, ownerPort
 
   return {
     async start () {
+      forget('a new start') // a session that ended without a close (killed, a crash) leaves nothing behind either
       await new Promise((res, rej) => { ctl.once('error', rej); ctl.listen(ctlPort, '127.0.0.1', res) })
       await new Promise((res, rej) => { gate.once('error', rej); gate.listen(gatePort, '127.0.0.1', res) })
       bound = gate.address().port
@@ -205,9 +235,11 @@ export function makeGate ({ ctlPort = CTL_PORT, gatePort = GATE_PORT, ownerPort
       try { child && child.kill() } catch { /* */ }
       for (let i = 0; i < 30 && child; i++) await sleep(100)
       try { child && child.kill('SIGKILL') } catch { /* */ }
+      for (let i = 0; i < 20 && child; i++) await sleep(100)
+      forget('it stopped')
       await new Promise((r) => ctl.close(() => r())); await new Promise((r) => gate.close(() => r())); await new Promise((r) => owner.close(() => r()))
     },
-    open, report, running, get realPort () { return realPort }, get takeover () { return takeover },
+    open, report, running, get private () { return priv }, get realPort () { return realPort }, get takeover () { return takeover },
   }
 }
 

{witbitz_code-1.11.0 → witbitz_code-1.13.0}/src/witbitz_code/pair.py

@@ -125,10 +125,22 @@ async def _link_by_qr(link_fn: LinkFn | None, out: Callable, err: Callable) -> d
     idx = account.get("idx")
     if not isinstance(idx, dict) or not truthy(idx.get("room")) or not truthy(idx.get("mk")):
         err("witbitz-code: the scan carried no index-room pointer, so there is nowhere to publish — nothing changed.")
+        await _report(account, False, "your account's list of devices could not be found from this phone. Open the app once, then scan again.")
         return None
     return account
 
 
+async def _report(account: dict | None, ok: bool, why: str = "") -> None:
+    """Tell the phone that sent the keys how pairing went (link.py's reporter; the owner, 2026-10-23: it said "Sent ✓" while
+    this computer refused the code). Best effort — never changes the outcome."""
+    r = account.get("_report") if isinstance(account, dict) else None
+    if callable(r):
+        try:
+            await r(ok, why)
+        except Exception:  # noqa: BLE001
+            pass
+
+
 async def rename(pairing: dict, name: str, *, call: net.ApiCall | None = None, out: Callable[[str], Any] = _out,
                  err: Callable[[str], Any] = _err) -> bool:
     """A pairing's label: in the account's computers (devices show it at their next sync), then in the pairings file. No scan."""
@@ -271,6 +283,8 @@ async def _run(args: Args, call: Any, link_fn: LinkFn | None, out: Callable, err
     if came != app.name():
         err(f"witbitz-code: ✖ that code came from the {app.label(came)} — this Witbitz Code is the {app.label()}'s. "
             f"Install the {app.label(came)}'s own from it: Code → Computers → Add a computer. Nothing changed.")
+        await _report(account, False, f"that computer's Witbitz Code is the {app.label()}'s. Install this app's own on it: "
+                                      "Code → Computers → Add a computer.")
         return 1
     port = None if args.opencode_url else pp.next_port(doc, account["idx"]["room"])  # another account: its own OpenCode
     u = pp.upsert_pairing(doc, account=account.get("email") or "", idx=account["idx"], name=args.name,
@@ -285,14 +299,17 @@ async def _run(args: Args, call: Any, link_fn: LinkFn | None, out: Callable, err
                                 computer_id=u["entry"]["computerId"], name=u["entry"]["name"])
     except codekeys.CodeKeyRefusal as e:
         err(f"witbitz-code: ✖ this computer got no coding keys: {e} — nothing changed.")
+        await _report(account, False, f"it got no coding keys: {e}")
         return 1
     ensure_local_password(out)
     if not await _publish_entry(call, u["entry"], out, err):
         await keys.revoke(entry)  # nothing is left live for a pairing that did not happen
         err("witbitz-code: nothing saved locally — scan again to retry.")
+        await _report(account, False, "it could not add itself to your account (offline?). Scan again to retry.")
         return 1
     codekeys.save(entry)
     pp.write_pairings(u["doc"])
+    await _report(account, True)  # the phone says "Added"
     e = u["entry"]
     out(f"witbitz-code: ✓ {'paired' if u['isNew'] else 'refreshed'} \"{e['name']}\" with {e['account'] or 'your account'} ({pp.pairings_path()})")
     caps = entry.get("caps") or {}

{witbitz_code-1.11.0 → witbitz_code-1.13.0/src/witbitz_code.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: witbitz-code
-Version: 1.11.0
+Version: 1.13.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.13.0/tests/test_browse.py

@@ -0,0 +1,97 @@
+"""The agent's browser on this computer (browse.py): the viewer key is the page's (codeRelay.js deriveBrowseKey), the files
+install and go, and it is ON unless turned off (the owner, 2026-10-19: "Both stages. Default.")."""
+import shutil
+import subprocess
+from pathlib import Path
+
+import pytest
+
+from witbitz_code import browse
+from witbitz_code.relay import browse_key
+
+ROOT = Path(__file__).resolve().parents[3]
+requires_node = pytest.mark.skipif(not shutil.which("node"), reason="node not installed")
+SECRET = "Y2bqk0a2N1pY9kQwF0x3c1u5mVb8zR2tL6eH4oJ7sD8"
+
+
+@requires_node
+def test_the_key_is_the_one_the_page_derives():
+    js = subprocess.run(["node", "-e", f"import('{ROOT}/spaces/public/codeRelay.js').then(async m => console.log(await m.deriveBrowseKey('{SECRET}')))"],
+                        capture_output=True, text=True, check=True).stdout.strip()
+    assert browse_key(SECRET) == js
+    assert len(__import__("base64").b64decode(js)) == 32
+
+
+def test_install_and_remove(tmp_path):
+    paths = browse.install(tmp_path)
+    for name in ("browse-local.mjs", "browse-cdp.mjs", "browse-publisher.mjs", "witbitz-browser.js"):
+        assert paths[name].exists(), name
+    assert (tmp_path / browse.PLUGIN_REL).exists()
+    browse.remove(tmp_path)
+    assert not (tmp_path / browse.PLUGIN_REL).exists()
+
+
+def test_on_by_default():
+    assert browse.disabled([], {}) is False
+    assert browse.disabled(["--no-browser"], {}) is True
+    assert browse.disabled([], {"WB_BROWSE_DISABLE": "1"}) is True
+
+
+def test_hello_carries_the_browse_report():
+    src = (Path(browse.__file__).parent / "connector.py").read_text(encoding="utf-8")
+    assert '**({"browse": browse} if browse else {})' in src
+    assert "browse_probe=browse_probe" in src
+
+
+# PRIVATE BROWSING ON YOUR OWN COMPUTER (the owner, 2026-10-24: "why not?" → "Yes"): the twin of tools/code-browse-private.test.mjs.
+def test_the_page_switches_private_browsing_with_a_nonce_checked_message():
+    import asyncio
+
+    from fakes import until
+    from test_connector_e2e import PyClient, Rig
+
+    from witbitz_code.connector import start_connector
+
+    async def go():
+        report = {"offered": True, "running": False, "local": True, "private": False, "canPrivate": True}
+        calls: list = []
+
+        async def set_private(on: bool) -> bool:
+            calls.append(on)
+            report["private"] = on
+            return True
+
+        async with Rig() as rig:
+            c = await start_connector([rig.pairing()], flush_ms=40, log=lambda m: None, browse_probe=lambda: dict(report),
+                                      browse_private=set_private)
+            client = PyClient(rig.secret, rig.relay.url)
+            try:
+                await client.start()
+                assert client.hellos()[-1]["browse"]["canPrivate"] is True
+                await client.peer.send({"t": "browse", "k": "not-the-nonce", "private": True})
+                await client.peer.send({"t": "browse", "k": client.nonce, "private": "yes"})
+                await asyncio.sleep(0.3)
+                assert calls == [], "a recording or a malformed message switches nothing"
+                await client.peer.send({"t": "browse", "k": client.nonce, "private": True})
+                assert await until(lambda: client.hellos()[-1].get("browse", {}).get("private") is True, 5)
+                assert calls == [True]
+            finally:
+                await client.peer.aclose()
+                await c.aclose()
+
+    asyncio.run(go())
+
+
+def test_a_tree_browser_takes_private_browsing_from_its_own_bundle_not_from_the_switch():
+    import asyncio
+
+    import httpx
+
+    from witbitz_code.browse import LocalBrowser
+
+    async def go():
+        b = LocalBrowser(None, 9, {}, httpx.AsyncClient(), tree="t1")  # type: ignore[arg-type]
+        assert await b.set_private(True) is False
+        await b._http.aclose()
+
+    asyncio.run(go())

{witbitz_code-1.11.0 → witbitz_code-1.13.0}/tests/test_codekeys.py

@@ -349,3 +349,38 @@ def test_the_python_and_node_connectors_read_each_others_keys_and_payers_files()
     pub.verify(codekeys._unb64u(out["body"]["sig"]), codekeys.signed_message("status", e["keyId"], 1800000000).encode())  # raises if not
     assert codekeys.for_computer("cmp_js")["trustedrouter"] == "sk-js" and SessionPayers().payer("ses_J") == "cmp_js"
     assert codekeys.signed_body("status", codekeys.for_computer("cmp_js"))["sig"], "Python signs with a Node-made key"
+
+
+@requires_node
+def test_a_status_that_names_its_app_moves_the_keys_there_and_saves_them(monkeypatch):
+    """The owner, 2026-10-23: each app its own computers and allowance. The status names this pairing's app and signs the
+    move ('move:<app>'); the server answers with a fresh pair under that app, which is opened and SAVED at once (the old one
+    is retired server-side, so unsaved keys would be lost)."""
+    from cryptography.hazmat.primitives.asymmetric import ed25519 as ed
+    T2, U2, K2 = "t_" + "c" * 32, "u_" + "d" * 24, "k_" + "2" * 24
+    ident = codekeys.new_identity()
+    entry = {**ident, "account": "me@x", "computerId": "cmp_1", "name": "desk", "keyId": f"{U}.{K}", "tenantId": T, "userId": U,
+             "kid": K, "trustedrouter": "sk-tr-old", "app": "regular"}
+    codekeys.save(entry)
+    sealed = run_node("import { sealForEnclave } from '@REPO@/control-plane/src/lib/enclaveKeySeal.mjs';"
+                      "OUT({ trustedrouter: await sealForEnclave('sk-tr-new', { tenantId: INPUT.t, userId: INPUT.u, kind: `code:${INPUT.k}:trustedrouter` }, INPUT.pub) })"
+                      .replace("@REPO@", (__import__("conftest").REPO).as_uri()),
+                      {"t": T2, "u": U2, "k": K2, "pub": codekeys.seal_pub(ident)})
+    seen = []
+
+    def handler(req):
+        b = json.loads(req.content)
+        seen.append(b)
+        pub = ed.Ed25519PublicKey.from_public_bytes(base64.urlsafe_b64decode(codekeys.sign_pub(ident) + "="))
+        pub.verify(base64.urlsafe_b64decode(b["moveSig"] + "=" * (-len(b["moveSig"]) % 4)), codekeys.signed_message("move:regular", b["keyId"], b["ts"]).encode())
+        return httpx.Response(200, json={"data": {"live": True, "moved": {"keyId": f"{U2}.{K2}", "tenantId": T2, "userId": U2, "kid": K2, "sealed": sealed, "caps": {"modelsUsd": 50}}}})
+
+    async def go():
+        async with client_for(handler) as c:
+            return await codekeys.status(c, entry)
+    st = run(go())
+    assert seen[0]["app"] == "regular"
+    assert st["live"] is True and st["movedTo"] == "regular"
+    saved = codekeys.for_computer("cmp_1")
+    assert (saved["keyId"], saved["tenantId"], saved["trustedrouter"]) == (f"{U2}.{K2}", T2, "sk-tr-new")
+    assert entry["trustedrouter"] == "sk-tr-new", "the running serve's entry follows too"

{witbitz_code-1.11.0 → witbitz_code-1.13.0}/tests/test_pair_flows.py

@@ -438,3 +438,35 @@ def test_a_store_moves_opencode_s_data_and_nothing_else(tmp_path, monkeypatch):
     monkeypatch.delenv("XDG_DATA_HOME", raising=False)
     asyncio.run(cli._start_opencode("opencode", 4096))
     assert "XDG_DATA_HOME" not in seen["env"], "the default store: OpenCode's own"
+
+
+def test_the_phone_that_sent_the_keys_hears_how_pairing_went(monkeypatch):
+    """The owner, 2026-10-23: the phone said "Sent ✓" while this computer refused the code. Each outcome after the link is
+    reported back (link.py's reporter → devicelink.seal_link_ack): paired, the other app's code, no keys, not published."""
+    def scan(origin="https://witbitz-spaces.pages.dev", **extra):
+        heard = []
+
+        async def report(ok, why=""):
+            heard.append((ok, why))
+
+        async def link_fn():
+            return {"email": "me@x", "idx": IDX, "master": "M" * 43, "anchor": ANCHOR, "origin": origin, "_report": report, **extra}
+        return link_fn, heard
+
+    link_fn, heard = scan()
+    assert run(pair.main(["--name", "desk"], call=MockApi().call, link_fn=link_fn, keys=FakeKeys(), **Capture().kw())) == 0
+    assert heard == [(True, "")]
+    assert "_report" not in pp.read_pairings()["pairings"][0], "the reporter is never saved"
+
+    link_fn, heard = scan("https://spaces.witbitz.chat")  # this install is the regular app's
+    assert run(pair.main([], call=MockApi().call, link_fn=link_fn, keys=FakeKeys(), **Capture().kw())) == 1
+    assert len(heard) == 1 and heard[0][0] is False and "regular app's" in heard[0][1] and "Add a computer" in heard[0][1]
+
+    link_fn, heard = scan()
+    keys = FakeKeys(refuse=("not_invited", "me@x is not on the list"))
+    assert run(pair.main([], call=MockApi().call, link_fn=link_fn, keys=keys, **Capture().kw())) == 1
+    assert heard == [(False, "it got no coding keys: me@x is not on the list")]
+
+    link_fn, heard = scan()
+    assert run(pair.main([], call=MockApi(read_status=503).call, link_fn=link_fn, keys=FakeKeys(), **Capture().kw())) == 1
+    assert heard and heard[0][0] is False and "Scan again" in heard[0][1]

{witbitz_code-1.11.0 → witbitz_code-1.13.0}/tests/test_selfupdate.py

@@ -105,3 +105,22 @@ def test_any_other_install_is_shown_the_command_never_run():
 def test_the_restart_runs_the_same_manager_with_the_same_arguments(monkeypatch):
     monkeypatch.setattr(su.sys, "argv", ["/x/bin/witbitz-code", "ui", "--hidden"])
     assert su.restart_argv() == [su.sys.executable, "-m", "witbitz_code", "ui", "--hidden"]
+
+
+def test_a_vaulted_install_checks_and_updates_through_its_own_installer(monkeypatch):
+    # The page's Update ran https://app.witbitz.chat/code.ps1 — the REGULAR app's installer — on every install, so a vaulted
+    # app's Witbitz Code updated into the regular app's (the owner, 2026-10-23). Each install reads and runs its own app's.
+    monkeypatch.setenv("WITBITZ_CODE_APP", "vaulted")
+    seen = {"urls": [], "launch": []}
+
+    async def fetch(url):
+        seen["urls"].append(url)
+        return script("9.9.9")
+    u = su.Updates(fetch_text=fetch, install_info=lambda: {"kind": "windows-installer"}, current="1.0.0",
+                   launch=lambda argv: seen["launch"].append(argv))
+    r = run(u.update())
+    assert r["ok"] and seen["urls"] and set(seen["urls"]) == {"https://app.witbitz.chat/code-vaulted.ps1"}
+    assert seen["launch"][0][-1] == "irm https://app.witbitz.chat/code-vaulted.ps1 | iex"
+    monkeypatch.setenv("WITBITZ_CODE_APP", "")
+    from witbitz_code import app
+    assert app.installer_url() == "https://app.witbitz.chat/code.ps1", "the regular app's, as every install before"

witbitz_code-1.11.0/tests/test_browse.py

@@ -1,43 +0,0 @@
-"""The agent's browser on this computer (browse.py): the viewer key is the page's (codeRelay.js deriveBrowseKey), the files
-install and go, and it is ON unless turned off (the owner, 2026-10-19: "Both stages. Default.")."""
-import shutil
-import subprocess
-from pathlib import Path
-
-import pytest
-
-from witbitz_code import browse
-from witbitz_code.relay import browse_key
-
-ROOT = Path(__file__).resolve().parents[3]
-requires_node = pytest.mark.skipif(not shutil.which("node"), reason="node not installed")
-SECRET = "Y2bqk0a2N1pY9kQwF0x3c1u5mVb8zR2tL6eH4oJ7sD8"
-
-
-@requires_node
-def test_the_key_is_the_one_the_page_derives():
-    js = subprocess.run(["node", "-e", f"import('{ROOT}/spaces/public/codeRelay.js').then(async m => console.log(await m.deriveBrowseKey('{SECRET}')))"],
-                        capture_output=True, text=True, check=True).stdout.strip()
-    assert browse_key(SECRET) == js
-    assert len(__import__("base64").b64decode(js)) == 32
-
-
-def test_install_and_remove(tmp_path):
-    paths = browse.install(tmp_path)
-    for name in ("browse-local.mjs", "browse-cdp.mjs", "browse-publisher.mjs", "witbitz-browser.js"):
-        assert paths[name].exists(), name
-    assert (tmp_path / browse.PLUGIN_REL).exists()
-    browse.remove(tmp_path)
-    assert not (tmp_path / browse.PLUGIN_REL).exists()
-
-
-def test_on_by_default():
-    assert browse.disabled([], {}) is False
-    assert browse.disabled(["--no-browser"], {}) is True
-    assert browse.disabled([], {"WB_BROWSE_DISABLE": "1"}) is True
-
-
-def test_hello_carries_the_browse_report():
-    src = (Path(browse.__file__).parent / "connector.py").read_text(encoding="utf-8")
-    assert '**({"browse": browse} if browse else {})' in src
-    assert "browse_probe=browse_probe" in src