witbitz-code 1.6.8__tar.gz → 1.6.10__tar.gz

{witbitz_code-1.6.8/src/witbitz_code.egg-info → witbitz_code-1.6.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: witbitz-code
-Version: 1.6.8
+Version: 1.6.10
 Summary: Reach OpenCode on this computer from the Witbitz Spaces Code section, through an end-to-end sealed relay.
 Author: Witbitz
 License-Expression: MIT
@@ -19,6 +19,7 @@ Requires-Dist: websockets>=13
 Requires-Dist: httpx>=0.25
 Requires-Dist: segno>=1.5
 Requires-Dist: tinfoil<0.15,>=0.14
+Requires-Dist: pillow>=10
 Provides-Extra: test
 Requires-Dist: pytest>=8; extra == "test"
 Requires-Dist: pyflakes>=3; extra == "test"

{witbitz_code-1.6.8 → witbitz_code-1.6.10}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "witbitz-code"
-version = "1.6.8"
+version = "1.6.10"
 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"
@@ -26,6 +26,8 @@ dependencies = [
   # Tinfoil's own verifier (attestation + Sigstore + TLS pinning) — the confidential proxy reads images and files a
   # text-only confidential model cannot, in Tinfoil's attested enclave (tinfoil_read.py). Pinned to a series on purpose.
   "tinfoil>=0.14,<0.15",
+  # Older screenshots are re-encoded smaller before a request leaves (images.py): TrustedRouter drops a ~10 MB request.
+  "pillow>=10",
 ]
 
 [project.optional-dependencies]

{witbitz_code-1.6.8 → witbitz_code-1.6.10}/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.6.8"
+__version__ = "1.6.10"

{witbitz_code-1.6.8 → witbitz_code-1.6.10}/src/witbitz_code/confidential.py

@@ -26,7 +26,7 @@ from typing import Any, Callable
 
 import httpx
 
-from . import keys, models as mdl, receipt as rcp, tinfoil_read
+from . import images, keys, models as mdl, receipt as rcp, tinfoil_read
 from .gateway import verify_gateway_attestation
 
 TR_UPSTREAM = "https://api.trustedrouter.com"
@@ -577,6 +577,12 @@ class ConfidentialProxy:
                 return
             req.headers = [(k, v) for k, v in req.headers if k.lower() not in ("authorization", "x-api-key")] + [("authorization", "Bearer " + cred["trustedrouter"])]
             tinfoil = cred.get("tinfoil") or ""
+        if isinstance(body, dict):
+            shrunk, rep = await asyncio.to_thread(images.shrink_older_images, body)
+            if shrunk is not body:
+                body, req.body = shrunk, dumps(shrunk).encode("utf-8")
+                if rep["dropped"]:
+                    self.log(f"code-confidential: the request was {rep['before'] // 1024} KB; {rep['dropped']} older screenshot(s) left out to send it")
         conf = self.models.get(body.get("model")) if isinstance(body, dict) and isinstance(body.get("model"), str) else None
         if not conf:
             await self._pass_through(req, res, body, target)

witbitz_code-1.6.10/src/witbitz_code/images.py

@@ -0,0 +1,125 @@
+"""OLDER IMAGES ARE SHRUNK BEFORE A REQUEST LEAVES THIS COMPUTER.
+
+OpenCode sends the whole conversation on every call, and every screenshot in it rides along as a full base64 PNG. A model
+reads an image as a fixed number of tokens whatever its bytes, so the context stays small while the REQUEST grows with each
+screenshot — and TrustedRouter drops a request of about 10 MB without answering (measured 2026-10-12: 9 MB answered,
+10 MB closed the connection; a session with 18 screenshots reached 11 MB and every message in it failed).
+
+So: the newest KEEP_FULL images go as they are; every older one is re-encoded as a JPEG no larger than MAX_SIDE on its
+longest side. A screenshot of ~1 MB becomes ~100–200 KB and still reads. The result is cached by content, so the same old
+screenshot shrinks to the same bytes on every call (a provider's prompt cache keeps working from there on). If the request
+is STILL over BUDGET, the oldest images are replaced by a one-line note, newest kept — a request that cannot be sent helps
+no one. No image library, or an image it cannot decode: that image is left as it is (the budget rule still applies).
+"""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import io
+import json
+import re
+from collections import OrderedDict
+from typing import Any
+
+KEEP_FULL = 3
+MAX_SIDE = 1280
+JPEG_QUALITY = 70
+BUDGET = 8 * 1024 * 1024  # bytes of request body; TrustedRouter's limit is ~10 MB
+CACHE_MAX = 256
+_DATA_URL = re.compile(r"^data:([^;,]+)?(?:;[^,]*)?;base64,(.*)$", re.S)
+
+_cache: "OrderedDict[str, str | None]" = OrderedDict()
+
+
+def _image_parts(body: dict) -> list[tuple[int, int]]:
+    """(message, part) of every inline image, oldest first."""
+    out = []
+    for mi, msg in enumerate(body.get("messages") or []):
+        content = msg.get("content") if isinstance(msg, dict) else None
+        if not isinstance(content, list):
+            continue
+        for pi, part in enumerate(content):
+            if isinstance(part, dict) and part.get("type") == "image_url" and _DATA_URL.match(str((part.get("image_url") or {}).get("url") or "")):
+                out.append((mi, pi))
+    return out
+
+
+def shrink_data_url(url: str) -> str | None:
+    """A smaller JPEG data URL for this image, or None (no library, cannot decode, or not smaller)."""
+    key = hashlib.sha256(url.encode("utf-8", "replace")).hexdigest()
+    if key in _cache:
+        _cache.move_to_end(key)
+        return _cache[key]
+    out = None
+    try:
+        from PIL import Image  # optional: without it, images go as they are
+        m = _DATA_URL.match(url)
+        raw = base64.b64decode(m.group(2), validate=False)
+        with Image.open(io.BytesIO(raw)) as im:
+            im.load()
+            im = im.convert("RGBA") if im.mode in ("P", "LA") else im
+            if im.mode == "RGBA":
+                bg = Image.new("RGB", im.size, (255, 255, 255))
+                bg.paste(im, mask=im.split()[3])
+                im = bg
+            elif im.mode != "RGB":
+                im = im.convert("RGB")
+            if max(im.size) > MAX_SIDE:
+                im.thumbnail((MAX_SIDE, MAX_SIDE), Image.LANCZOS)
+            buf = io.BytesIO()
+            im.save(buf, "JPEG", quality=JPEG_QUALITY, optimize=True)
+        small = "data:image/jpeg;base64," + base64.b64encode(buf.getvalue()).decode("ascii")
+        out = small if len(small) < len(url) else None
+    except Exception:  # noqa: BLE001 — an image we cannot shrink is sent as it is
+        out = None
+    _cache[key] = out
+    while len(_cache) > CACHE_MAX:
+        _cache.popitem(last=False)
+    return out
+
+
+def _size(body: dict) -> int:
+    return len(json.dumps(body, separators=(",", ":"), ensure_ascii=False).encode("utf-8"))
+
+
+def shrink_older_images(body: Any, keep_full: int = KEEP_FULL, budget: int = BUDGET) -> tuple[Any, dict]:
+    """(body, report). The body is a NEW dict when anything changed; the input is never mutated."""
+    report = {"shrunk": 0, "dropped": 0, "before": 0, "after": 0}
+    if not isinstance(body, dict):
+        return body, report
+    parts = _image_parts(body)
+    if not parts:
+        return body, report
+    messages = list(body["messages"])
+    touched: set[int] = set()
+
+    def put(mi: int, pi: int, part: dict) -> None:
+        if mi not in touched:
+            messages[mi] = {**messages[mi], "content": list(messages[mi]["content"])}
+            touched.add(mi)
+        messages[mi]["content"][pi] = part
+
+    older = parts[:-keep_full] if keep_full > 0 else parts
+    for mi, pi in older:
+        part = messages[mi]["content"][pi]
+        small = shrink_data_url(part["image_url"]["url"])
+        if small:
+            put(mi, pi, {**part, "image_url": {**part["image_url"], "url": small}})
+            report["shrunk"] += 1
+    out = {**body, "messages": messages} if touched else body
+    size = _size(out)
+    if size > budget:
+        report["before"] = size
+        for mi, pi in parts[:-1]:  # the newest image is never dropped
+            if size <= budget:
+                break
+            part = messages[mi]["content"][pi]
+            was = len(json.dumps(part, separators=(",", ":"), ensure_ascii=False).encode("utf-8"))
+            note = {"type": "text", "text": "[An earlier screenshot was removed here to keep the request small enough to send.]"}
+            put(mi, pi, note)
+            size -= was - len(json.dumps(note, separators=(",", ":")).encode("utf-8"))
+            report["dropped"] += 1
+        out = {**body, "messages": messages}
+        report["after"] = size
+    return out, report

{witbitz_code-1.6.8 → witbitz_code-1.6.10}/src/witbitz_code/uninstall.py

@@ -302,11 +302,26 @@ def remove_opencode_program(info: dict) -> dict:
     return {"ok": False, "why": f"{info['path']} is still there", "said": said} if os.path.exists(info["path"]) else {"ok": True, "said": said}
 
 
+WINDOWS_REINSTALL = "irm https://app.witbitz.chat/code.ps1 | iex"
+
+
+def windows_installer_root() -> str:
+    """%LOCALAPPDATA%\\Witbitz — where the Windows installer (code.ps1) puts this program, OpenCode and the uninstaller."""
+    base = os.environ.get("LOCALAPPDATA") or ""
+    return (base.rstrip("\\/") + "\\Witbitz") if base else ""
+
+
 def pipx_install() -> dict:
-    """This package as pipx installed it → {"kind": "pipx", "venv"} (removable with `pipx uninstall`), else pip / other."""
+    """This package as pipx installed it → {"kind": "pipx", "venv"} (removable with `pipx uninstall`); as the Windows
+    installer (code.ps1) installed it → {"kind": "windows-installer"} (its own uninstaller removes the program, OpenCode
+    and the folder right after this — recognised by the flag it sets, or by where the program lives, so an uninstaller
+    written by an older install is covered too); else pip / other."""
     prefix = Path(sys.prefix)
     if (prefix / "pipx_metadata.json").exists():  # pipx writes it into every venv it makes, wherever PIPX_HOME is
         return {"kind": "pipx", "venv": str(prefix)}
+    root = windows_installer_root()
+    if os.environ.get("WITBITZ_INSTALLER") == "windows" or (root and str(sys.prefix).lower().startswith(root.lower() + "\\")):
+        return {"kind": "windows-installer"}
     return {"kind": "pip", "hint": f"{Path(sys.executable).name} -m pip uninstall witbitz-code"}
 
 
@@ -364,9 +379,12 @@ async def run_uninstall(d: Deps) -> dict:
     d.say(f"  • delete {d.code_dir} (the pairing secrets, files you attached in Code, the Auto-mode log)")
     if owned:
         d.say(f"  • remove what witbitz-code added to OpenCode ({len(owned)} item{'s' if len(owned) > 1 else ''}: the project-notes and progress plugins, the media and code tools)")
+    winst = pkg["kind"] == "windows-installer"
     if pkg["kind"] == "pipx":
         d.say("  • uninstall the witbitz-code program (pipx uninstall witbitz-code)")
-    d.say("It keeps OpenCode and your projects — and, unless you say so next, your keys, notes and sessions.\n")
+    if winst:
+        d.say("  • then the Windows uninstaller removes the program, OpenCode and the Witbitz folder")
+    d.say(("It keeps your projects" if winst else "It keeps OpenCode and your projects") + " — and, unless you say so next, your keys, notes and sessions.\n")
     if not d.yes and not d.ask("Continue? [y/N] ").strip().lower().startswith("y"):
         d.say("Nothing changed.")
         return {"done": False}
@@ -469,21 +487,22 @@ async def run_uninstall(d: Deps) -> dict:
         pkg_gone = bool(r.get("ok"))
         d.say("✓ Uninstalled the witbitz-code program" if pkg_gone else f"✖ Could not uninstall the program ({r.get('why')}) — run: pipx uninstall witbitz-code")
     d.say("")
-    if pairs:
+    winst = pkg["kind"] == "windows-installer"
+    if pairs and not winst:  # the Windows uninstaller stops whatever still runs from its folder
         d.say("If witbitz-code serve is still running in a terminal window, close that window (Ctrl-C).")
     if left:
         d.say(f"Your phone may still list {', '.join(chr(34) + str(p.get('name')) + chr(34) for p in left)}: open Code → Settings → Remove there"
               " — that also cancels its coding keys.")
-    if pkg["kind"] != "pipx":
+    if pkg["kind"] not in ("pipx", "windows-installer"):
         d.say(f"To remove the program itself: {pkg.get('hint')}")
     if oc_gone:
         tail = "" if remove_sessions else f"\nOpenCode's own data stays: {sessions['dir']} (sessions, saved logins) and its settings in ~/.config/opencode — delete those folders to remove everything."
         d.say(f"witbitz-code and OpenCode are removed. Open a new terminal window so it forgets the old PATH.{tail}")
-    elif oc["kind"] != "none":
+    elif oc["kind"] != "none" and not winst:
         d.say(f"witbitz-code is removed. OpenCode is still installed — to remove it too: {oc.get('hint')}")
     else:
         d.say("witbitz-code is removed.")
-    d.say("To start again: pipx install witbitz-code, then witbitz-code setup.")
+    d.say(f"To install again: {WINDOWS_REINSTALL}" if winst else "To start again: pipx install witbitz-code, then witbitz-code setup.")
     return {"done": True, "left": len(left), "package": pkg_gone}
 
 

{witbitz_code-1.6.8 → witbitz_code-1.6.10/src/witbitz_code.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: witbitz-code
-Version: 1.6.8
+Version: 1.6.10
 Summary: Reach OpenCode on this computer from the Witbitz Spaces Code section, through an end-to-end sealed relay.
 Author: Witbitz
 License-Expression: MIT
@@ -19,6 +19,7 @@ Requires-Dist: websockets>=13
 Requires-Dist: httpx>=0.25
 Requires-Dist: segno>=1.5
 Requires-Dist: tinfoil<0.15,>=0.14
+Requires-Dist: pillow>=10
 Provides-Extra: test
 Requires-Dist: pytest>=8; extra == "test"
 Requires-Dist: pyflakes>=3; extra == "test"

{witbitz_code-1.6.8 → witbitz_code-1.6.10}/src/witbitz_code.egg-info/SOURCES.txt

@@ -21,6 +21,7 @@ src/witbitz_code/devicelink.py
 src/witbitz_code/dirs.py
 src/witbitz_code/folders.py
 src/witbitz_code/gateway.py
+src/witbitz_code/images.py
 src/witbitz_code/keys.py
 src/witbitz_code/link.py
 src/witbitz_code/mkdir.py
@@ -77,6 +78,7 @@ tests/test_devicelink.py
 tests/test_dirs.py
 tests/test_files_and_compress.py
 tests/test_folders.py
+tests/test_images.py
 tests/test_outputs.py
 tests/test_pair_flows.py
 tests/test_plugins.py

{witbitz_code-1.6.8 → witbitz_code-1.6.10}/src/witbitz_code.egg-info/requires.txt

@@ -3,6 +3,7 @@ websockets>=13
 httpx>=0.25
 segno>=1.5
 tinfoil<0.15,>=0.14
+pillow>=10
 
 [test]
 pytest>=8

witbitz_code-1.6.10/tests/test_images.py

@@ -0,0 +1,102 @@
+"""Older screenshots are shrunk before a request leaves (images.py) — a session with 18 full PNGs reached 11 MB and
+TrustedRouter dropped every call in it without answering."""
+
+import base64
+import io
+import json
+import os
+
+from PIL import Image
+
+from witbitz_code import images
+from test_confidential import needs_fixture, with_proxy
+
+
+def png_url(seed: int, side: int = 1800) -> str:
+    """A noisy PNG (noise does not compress, like a real screenshot full of text)."""
+    im = Image.frombytes("RGB", (side, side * 2 // 3), os.urandom(side * (side * 2 // 3) * 3) if seed >= 0 else b"\0" * (side * (side * 2 // 3) * 3))
+    buf = io.BytesIO()
+    im.save(buf, "PNG")
+    return "data:image/png;base64," + base64.b64encode(buf.getvalue()).decode()
+
+
+def body_with(urls):
+    msgs = [{"role": "system", "content": "be useful"}]
+    for i, u in enumerate(urls):
+        msgs.append({"role": "user", "content": [{"type": "text", "text": f"shot {i}"}, {"type": "image_url", "image_url": {"url": u}}]})
+    msgs.append({"role": "user", "content": "Hi"})
+    return {"model": "openai/gpt-6-sol", "messages": msgs, "stream": True}
+
+
+def urls_of(body):
+    return [p["image_url"]["url"] for m in body["messages"] if isinstance(m.get("content"), list) for p in m["content"] if p.get("type") == "image_url"]
+
+
+def test_the_newest_images_go_as_they_are_and_older_ones_become_small_jpegs():
+    urls = [png_url(i, 900) for i in range(5)]
+    body = body_with(urls)
+    out, rep = images.shrink_older_images(body, keep_full=3)
+    got = urls_of(out)
+    assert got[2:] == urls[2:], "the newest three are untouched"
+    assert all(u.startswith("data:image/jpeg;base64,") for u in got[:2]) and rep["shrunk"] == 2
+    assert all(len(a) < len(b) for a, b in zip(got[:2], urls[:2]))
+    assert urls_of(body) == urls, "the input is never changed"
+    Image.open(io.BytesIO(base64.b64decode(got[0].split(",", 1)[1]))).verify()
+
+
+def test_a_large_screenshot_is_brought_down_to_max_side():
+    out, _ = images.shrink_older_images(body_with([png_url(1, 2400), png_url(2, 300)]), keep_full=1)
+    with Image.open(io.BytesIO(base64.b64decode(urls_of(out)[0].split(",", 1)[1]))) as im:
+        assert max(im.size) == images.MAX_SIDE
+
+
+def test_the_same_old_image_shrinks_to_the_same_bytes_every_call():
+    urls = [png_url(i, 700) for i in range(4)]
+    a, _ = images.shrink_older_images(body_with(urls), keep_full=1)
+    images._cache.clear()
+    b, _ = images.shrink_older_images(body_with(urls), keep_full=1)
+    assert urls_of(a) == urls_of(b), "deterministic, so a provider's prompt cache keeps working"
+
+
+def test_no_images_or_only_new_ones_leave_the_body_as_it_was():
+    plain = {"model": "m", "messages": [{"role": "user", "content": "hi"}]}
+    assert images.shrink_older_images(plain)[0] is plain
+    few = body_with([png_url(1, 300)])
+    assert images.shrink_older_images(few)[0] is few
+
+
+def test_an_image_it_cannot_decode_is_sent_as_it_is():
+    bad = "data:image/png;base64," + base64.b64encode(b"not an image" * 50).decode()
+    body = body_with([bad, png_url(1, 300)])
+    out, rep = images.shrink_older_images(body, keep_full=1)
+    assert urls_of(out)[0] == bad and rep["shrunk"] == 0
+
+
+def test_over_the_budget_the_oldest_images_become_a_note_and_the_newest_stays():
+    urls = [png_url(i, 900) for i in range(4)]
+    body = body_with(urls)
+    out, rep = images.shrink_older_images(body, keep_full=4, budget=len(urls[0]) * 2)
+    assert rep["dropped"] >= 1 and urls_of(out)[-1] == urls[-1]
+    assert len(json.dumps(out)) <= len(urls[0]) * 2 + 2000
+    assert any(p.get("type") == "text" and "screenshot was removed" in p["text"] for m in out["messages"] if isinstance(m["content"], list) for p in m["content"])
+
+
+def test_the_owners_session_shape_fits_under_trustedrouters_limit():
+    """18 screenshots of ~0.6 MB: 11 MB before; now well under the 10 MB TrustedRouter takes."""
+    urls = [png_url(i, 1100) for i in range(18)]
+    body = body_with(urls)
+    before = len(json.dumps(body))
+    out, _ = images.shrink_older_images(body)
+    after = len(json.dumps(out))
+    assert before > 10 * 1024 * 1024 and after < images.BUDGET, (before, after)
+
+
+@needs_fixture
+def test_the_proxy_sends_the_shrunk_body_upstream():
+    urls = [png_url(i, 900) for i in range(5)]
+
+    async def t(post, net, _p):
+        await post(body_with(urls))
+        sent = urls_of(json.loads(net.calls[0]["body"]))
+        assert sent[2:] == urls[2:] and all(u.startswith("data:image/jpeg") for u in sent[:2])
+    with_proxy(t)

{witbitz_code-1.6.8 → witbitz_code-1.6.10}/tests/test_uninstall.py

@@ -210,3 +210,28 @@ def test_windows_finds_opencode_by_name():
     out = '"opencode.exe","19228","Console","1","95,000 K","Running","ALONASUS\\shter","0:00:03","N/A"\n' \
           '"opencode.exe","555","Console","1","1 K","Running","OTHER\\bob","0:00:01","N/A"\n'
     assert un.win_opencode_processes(run=lambda argv: out, user="shter") == [{"pid": 19228, "cmd": "opencode.exe"}]
+
+
+# THE WINDOWS INSTALLER (code.ps1) — the owner, 2026-10-11, Settings → Apps → Witbitz Code → Uninstall printed pip/pipx advice:
+# "To remove the program itself: python.exe -m pip uninstall witbitz-code", "OpenCode is still installed … remove it the
+# way it was installed", "To start again: pipx install witbitz-code". That uninstaller removes the program, OpenCode (in
+# %LOCALAPPDATA%\Witbitz\bin) and the folder right after this, and stops anything still running from it.
+def test_under_the_windows_installer_the_summary_says_what_that_uninstaller_does_not_pip_or_pipx_advice():
+    f = Fake(answers=["y"], pairs=[PAIR], oc="installer", pkg="windows-installer")
+    r = run(un.run_uninstall(f.deps(yes=True)))
+    said = "\n".join(f.said)
+    assert r["done"]
+    for wrong in ("pip uninstall", "pipx", "OpenCode is still installed", "still running in a terminal window"):
+        assert wrong not in said, f"{wrong!r} does not apply to the Windows installer:\n{said}"
+    assert "irm https://app.witbitz.chat/code.ps1 | iex" in said, said
+    assert ("package",) not in f.done, "the Windows uninstaller removes the program itself"
+
+
+def test_the_windows_installer_is_recognised_by_where_the_program_lives_even_from_an_older_uninstaller(monkeypatch):
+    monkeypatch.delenv("WITBITZ_INSTALLER", raising=False)
+    monkeypatch.setenv("LOCALAPPDATA", r"C:\Users\shter\AppData\Local")
+    monkeypatch.setattr(un.sys, "prefix", r"C:\Users\shter\AppData\Local\Witbitz\venv")
+    assert un.pipx_install()["kind"] == "windows-installer"
+    monkeypatch.setattr(un.sys, "prefix", "/home/a/.local/pipx/venvs/witbitz-code")
+    monkeypatch.setenv("WITBITZ_INSTALLER", "windows")
+    assert un.pipx_install()["kind"] == "windows-installer", "or by the flag the new uninstaller sets"