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

{witbitz_code-1.12.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.12.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.12.0 → witbitz_code-1.13.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "witbitz-code"
-version = "1.12.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.12.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.12.0"
+__version__ = "1.13.0"

{witbitz_code-1.12.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.12.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.12.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.12.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.12.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.12.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.12.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.12.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.12.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.12.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.12.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.12.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