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

{witbitz_code-1.12.0/src/witbitz_code.egg-info → witbitz_code-1.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: witbitz-code
-Version: 1.12.0
+Version: 1.14.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.14.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "witbitz-code"
-version = "1.12.0"
+version = "1.14.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.14.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.14.0"

{witbitz_code-1.12.0 → witbitz_code-1.14.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.14.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.14.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
@@ -39,6 +39,7 @@ from .attachments import (ATTACHMENT_ROUTE, MAX_FILE_BYTES, attachment_rule, def
 from .auto_runner import AutoRunner, detail_of
 from .remind import ReminderClock, seal as seal_remind, valid as valid_remind  # "waiting for your approval" (docs/approval-reminders.md)
 from .outputs import OUTPUT_ROUTE, serve_output
+from .files import FILES_DOWNLOAD_ROUTE, FILES_UPLOAD_ROUTE, download_file, upload_file
 from .plugins import notes_plugin_path as default_notes_plugin, notes_root as default_notes_root, notes_rules
 from .payers import SessionPayers
 from .seen import SEEN_ROUTE, merge_seen, norm_seen
@@ -162,8 +163,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
@@ -316,7 +319,7 @@ class PairingServer:
         self._browse_said = json.dumps(browse, sort_keys=True)
         # caps: what this connector can do beyond the requests — a page shows the Auto switch only when `auto` is here.
         return self.peer.send({"t": "hello", "ver": VERSION, "name": self.name, "computerId": self.pairing.get("computerId") or "",
-                               "k": self.nonce, "ts": int(time.time() * 1000), "caps": ["auto", "attachments", "outputs", "tools", "seen", "asks", "folders", "remind"], "auto": self.auto.sessions(),
+                               "k": self.nonce, "ts": int(time.time() * 1000), "caps": ["auto", "attachments", "outputs", "tools", "seen", "asks", "folders", "remind", "files"], "auto": self.auto.sessions(),
                                **({"browse": browse} if browse else {})})
 
     def _auth(self) -> dict:
@@ -355,6 +358,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
@@ -409,6 +418,39 @@ class PairingServer:
                               "stat": stat_only, "st": st})
             await reply(st, b)
             return
+        # The Files sheet (files.py ⇄ tools/code-files.mjs): Download any file of the session's folder — nothing secret-looking —
+        # and Upload into it. Answered HERE; the folder is the session's, as OpenCode reports it; logged as a digest of the path.
+        if (m.get("m") == "GET" and bare == FILES_DOWNLOAD_ROUTE) or (m.get("m") == "POST" and bare == FILES_UPLOAD_ROUTE):
+            q = dict(urllib.parse.parse_qsl(query, keep_blank_values=True))
+            sid = q.get("session", "")
+            if not re.fullmatch(r"[A-Za-z0-9_-]{1,128}", sid):
+                await reply(400, {"error": "not a session id"})
+                return
+            dir_query = "directory=" + urllib.parse.quote(q["directory"], safe="!'()*") if q.get("directory") else ""  # encodeURIComponent
+            session = await self._session_for(sid, dir_query)
+            if not session or not isinstance(session.get("directory"), str):
+                await reply(404, {"error": "no such session on this computer"})
+                return
+            now = int(time.time() * 1000)
+            if m.get("m") == "GET":
+                st, b = download_file(directory=session["directory"], path=q.get("path"))
+                self._log_output({"at": now, "session": sid, "digest": hashlib.sha256(q.get("path", "").encode()).hexdigest(),
+                                  "download": True, "st": st})
+                await reply(st, b)
+                return
+            try:
+                f = json.loads(m.get("b") or "null")
+            except ValueError:
+                f = None
+            if not isinstance(f, dict):
+                await reply(400, {"error": "no file"})
+                return
+            st, b = upload_file(directory=session["directory"], dir=f.get("dir"), name=f.get("name"), b64=f.get("b64"),
+                                replace=f.get("replace") is True)
+            self._log_output({"at": now, "session": sid, "digest": hashlib.sha256(f"{f.get('dir')}/{f.get('name')}".encode()).hexdigest(),
+                              "upload": True, "st": st})
+            await reply(st, b)
+            return
         # What the person has seen, shared by their devices (seen.py): answered HERE and kept on this computer.
         if bare == SEEN_ROUTE and m.get("m") in ("GET", "POST"):
             if m.get("m") == "GET":
@@ -964,7 +1006,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 +1023,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.14.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.14.0/src/witbitz_code/files.py

@@ -0,0 +1,110 @@
+"""The Files sheet in a Code session — tools/code-files.mjs, in Python.
+
+DOWNLOAD (GET /witbitz/download?session=&path=): serve_output with `any_kind` — in the session's folder, no link out, nothing
+secret-looking, 20 MB; any regular file. UPLOAD (POST /witbitz/upload?session=, body {dir, name, b64, replace}): one file
+name (is_upload_name), into a folder whose REAL path is the session's or under it; a name already there is refused (409)
+unless `replace`, and a folder or link under that name is never replaced. Written to a hidden temporary beside it and renamed
+into place. As root, the file takes the uid/gid of the folder it lands in (a cloud computer's connector writing for the agent);
+anyone else is the person, and nothing changes.
+"""
+
+from __future__ import annotations
+
+import base64
+import binascii
+import json
+import os
+import re
+import secrets
+import stat as stat_mod
+import unicodedata
+from typing import Any
+
+from .attachments import MAX_SERVE_BYTES
+from .auto import posix_normalize
+from .outputs import serve_output, valid_output_path
+
+FILES_DOWNLOAD_ROUTE = "/witbitz/download"
+FILES_UPLOAD_ROUTE = "/witbitz/upload"
+MAX_FILE_TRANSFER = MAX_SERVE_BYTES  # 20 MB: base64 in one relay message stays under its 32 MiB reassembly cap
+_B64 = re.compile(r"[A-Za-z0-9+/]*={0,2}\Z")
+
+
+def is_upload_name(n: Any) -> bool:
+    """A FILE's name (⇄ code-files.mjs isUploadName): no / or \\ or NUL, not hidden, at most 200 characters, nothing
+    invisible (a control or format character — a direction mark, a zero-width space), no surrounding spaces."""
+    s = unicodedata.normalize("NFC", n) if isinstance(n, str) else ""
+    return (bool(s) and len(s) <= 200 and not s.startswith(".") and not re.search(r"[/\\\0]", s)
+            and not any(unicodedata.category(c) in ("Cc", "Cf") for c in s) and s.strip() == s)
+
+
+def _answer(st: int, o: dict) -> tuple[int, str]:
+    return st, json.dumps(o, ensure_ascii=False, separators=(",", ":"))
+
+
+def _as_root() -> bool:
+    return hasattr(os, "geteuid") and os.geteuid() == 0
+
+
+def download_file(*, directory: Any, path: Any, max_bytes: int = MAX_FILE_TRANSFER) -> tuple[int, str]:
+    return serve_output(directory=directory, path=path, max_bytes=max_bytes, any_kind=True)
+
+
+def upload_file(*, directory: Any, dir: Any, name: Any, b64: Any, replace: bool = False,
+                max_bytes: int = MAX_FILE_TRANSFER, as_root: bool | None = None) -> tuple[int, str]:
+    as_root = _as_root() if as_root is None else as_root
+    if isinstance(name, str):
+        name = unicodedata.normalize("NFC", name)
+    if not is_upload_name(name):
+        return _answer(400, {"error": "a file name: no / or \\, not hidden, nothing invisible"})
+    if not isinstance(directory, str) or not directory.startswith("/") or not valid_output_path(dir):
+        return _answer(400, {"error": "not a folder in this session"})
+    root = re.sub(r"/+\Z", "", posix_normalize(directory))
+    where = re.sub(r"/+\Z", "", posix_normalize(dir)) or "/"
+    if not root or not (where == root or where.startswith(root + "/")):
+        return _answer(403, {"error": "that folder is outside the session's folder"})
+    if not isinstance(b64, str) or not _B64.match(b64):
+        return _answer(400, {"error": "not a file's bytes"})
+    try:
+        data = base64.b64decode(b64, validate=True)
+    except (binascii.Error, ValueError):
+        return _answer(400, {"error": "not a file's bytes"})
+    if len(data) > max_bytes:
+        return _answer(413, {"error": f"the file is over {round(max_bytes / 1048576)} MB — too large to send to the computer"})
+    try:
+        real_root = os.path.realpath(root, strict=True)
+    except OSError:
+        return _answer(404, {"error": "the session's folder is not on this computer"})
+    try:
+        real_where = os.path.realpath(where, strict=True)
+    except OSError:
+        return _answer(404, {"error": "that folder is not on the computer (any more)"})
+    if not (real_where == real_root or real_where.startswith(real_root + "/")):
+        return _answer(403, {"error": "that folder leads outside the session's folder"})
+    folder = os.stat(real_where)
+    if not stat_mod.S_ISDIR(folder.st_mode):
+        return _answer(400, {"error": "not a folder"})
+    target = os.path.join(real_where, name)
+    try:
+        there = os.lstat(target)
+    except OSError:
+        there = None
+    if there is not None and not stat_mod.S_ISREG(there.st_mode):
+        return _answer(409, {"error": "a folder or link of that name is there", "exists": True, "replaceable": False})
+    if there is not None and not replace:
+        return _answer(409, {"error": "a file of that name is already there", "exists": True, "replaceable": True})
+    tmp = os.path.join(real_where, f".{name}.upload-{secrets.token_hex(6)}")
+    try:
+        fd = os.open(tmp, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o644)
+        with os.fdopen(fd, "wb") as f:
+            f.write(data)
+        if as_root:
+            os.chown(tmp, folder.st_uid, folder.st_gid)
+        os.replace(tmp, target)
+    except OSError as e:
+        try:
+            os.unlink(tmp)
+        except OSError:
+            pass
+        return _answer(500, {"error": f"could not save it here ({str(e)[:120]})"})
+    return _answer(200, {"ok": True, "name": name, "path": target, "size": len(data), "replaced": there is not None})

{witbitz_code-1.12.0 → witbitz_code-1.14.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.14.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.14.0}/src/witbitz_code/outputs.py

@@ -71,8 +71,12 @@ def _answer(st: int, o: dict) -> tuple[int, str]:
     return st, _js.stringify(o)
 
 
-def serve_output(*, directory: Any, path: Any, stat: bool = False, max_bytes: int = MAX_SERVE_BYTES) -> tuple[int, str]:
-    """One produced file (or its facts, with `stat`) for the page: (status, JSON body) in the connector's reply shape."""
+def serve_output(*, directory: Any, path: Any, stat: bool = False, max_bytes: int = MAX_SERVE_BYTES,
+                 any_kind: bool = False) -> tuple[int, str]:
+    """One produced file (or its facts, with `stat`) for the page: (status, JSON body) in the connector's reply shape.
+
+    `any_kind`: the Files sheet's Download (files.py) — any regular file, not only a kind the page previews; every other
+    check stays (⇄ tools/code-outputs.mjs)."""
     if not isinstance(directory, str) or not directory.startswith("/") or not valid_output_path(path):
         return _answer(400, {"error": "not a file in this session"})
     d = re.sub(r"/+\Z", "", posix_normalize(directory))
@@ -81,7 +85,7 @@ def serve_output(*, directory: Any, path: Any, stat: bool = False, max_bytes: in
         return _answer(403, {"error": "that file is outside the session's folder"})
     if _sensitive_path(a[len(d):]):
         return _answer(403, {"error": "not shown: the name looks like a secret"})
-    if not output_kind(a):
+    if not any_kind and not output_kind(a):
         return _answer(400, {"error": "not a file the page shows"})
     try:
         real_dir = os.path.realpath(d, strict=True)
@@ -95,7 +99,7 @@ def serve_output(*, directory: Any, path: Any, stat: bool = False, max_bytes: in
         return _answer(403, {"error": "that file leads outside the session's folder"})
     if _sensitive_path(real[len(real_dir):]):
         return _answer(403, {"error": "not shown: the file looks like a secret"})
-    kind = output_kind(real)
+    kind = output_kind(real) or ("file" if any_kind else None)
     if not kind:
         return _answer(400, {"error": "not a file the page shows"})
     try:

{witbitz_code-1.12.0 → witbitz_code-1.14.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.14.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.14.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.14.0}/src/witbitz_code.egg-info/SOURCES.txt

@@ -22,6 +22,7 @@ src/witbitz_code/confidential_models.json
 src/witbitz_code/connector.py
 src/witbitz_code/devicelink.py
 src/witbitz_code/dirs.py
+src/witbitz_code/files.py
 src/witbitz_code/folders.py
 src/witbitz_code/gateway.py
 src/witbitz_code/images.py
@@ -89,6 +90,7 @@ tests/test_confidential.py
 tests/test_connector_e2e.py
 tests/test_devicelink.py
 tests/test_dirs.py
+tests/test_files.py
 tests/test_files_and_compress.py
 tests/test_folders.py
 tests/test_images.py

{witbitz_code-1.12.0 → witbitz_code-1.14.0}/tests/test_auto.py

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