witbitz-code 1.7.2__tar.gz → 1.7.4__tar.gz

{witbitz_code-1.7.2/src/witbitz_code.egg-info → witbitz_code-1.7.4}/PKG-INFO

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

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

{witbitz_code-1.7.2 → witbitz_code-1.7.4}/src/witbitz_code/confidential.py

@@ -627,7 +627,11 @@ class ConfidentialProxy:
             hold = attempt["n"] > 1 or (ends is not None and self._now() / 1000 >= ends - HOLD_BEFORE_LAPSE_SEC)
             n = self._nonce()
             raw = dumps(stamp_floor(body)).encode("utf-8")
-            headers = {**_forward_headers(req.headers), "content-type": "application/json", "x-inference-receipt": n}
+            # the forwarded headers WITHOUT their own content-type / x-inference-receipt, whatever their case: OpenCode sends
+            # "Content-Type", and two of them made TrustedRouter refuse every confidential call (2026-10-17: a small one 400
+            # "could not read request"; a large one closed mid-upload — an empty httpx ReadError, "could not reach TrustedRouter ()")
+            fwd = {k: v for k, v in _forward_headers(req.headers).items() if k.lower() not in ("content-type", "x-inference-receipt")}
+            headers = {**fwd, "content-type": "application/json", "x-inference-receipt": n}
             tell("waiting", bytes=len(raw))
             async with self.client.stream("POST", target, headers=headers, content=raw) as up:
                 if not up.is_success:

witbitz_code-1.7.4/src/witbitz_code/selfupdate.py

@@ -0,0 +1,120 @@
+"""Update witbitz-code from its page (the owner, 2026-10-17: a fix on PyPI reached no computer that already had it).
+
+The version to run is the one the Windows installer pins (`$WitbitzCode` in https://app.witbitz.chat/code.ps1): that
+installer is served from the OFFICIAL release, so a computer moves when Witbitz releases — never to an upload that has
+not been released, and the same version for a Windows, WSL, Mac or Linux install.
+
+How it updates follows how it was installed (uninstall.pipx_install):
+  · the Windows installer → run that installer again in a window you can see: it stops this copy, installs the pinned
+    version and opens the page again (code.ps1 does all of it already);
+  · pipx → `pipx install --force witbitz-code==<v>`, then this manager starts itself again (ui.run re-executes);
+  · anything else → the command to run, shown on the page.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import shutil
+import subprocess
+import sys
+import time
+from collections.abc import Awaitable, Callable
+from typing import Any
+
+from . import __version__, uninstall
+
+INSTALLER_URL = "https://app.witbitz.chat/code.ps1"
+CHECK_EVERY_S = 6 * 3600
+_PIN = re.compile(r"""^\s*\$WitbitzCode\s*=\s*'(\d{1,4}\.\d{1,4}\.\d{1,4})'\s*$""", re.M)
+
+
+def parse_pin(script: str) -> str | None:
+    """The version code.ps1 installs — None when the script does not say it the one way it does."""
+    m = _PIN.search(script or "")
+    return m.group(1) if m else None
+
+
+def newer(a: str, b: str) -> bool:
+    """Is version `a` newer than `b`? (x.y.z only; anything else is never newer.)"""
+    try:
+        return tuple(int(x) for x in a.split(".")) > tuple(int(x) for x in b.split("."))
+    except (ValueError, AttributeError):
+        return False
+
+
+def how(info: dict, version: str) -> dict:
+    """What the Update button does here → {"kind": "installer"|"pipx"|"manual", "command"?}."""
+    kind = info.get("kind")
+    if kind == "windows-installer":
+        return {"kind": "installer"}
+    if kind == "pipx" and shutil.which("pipx"):
+        return {"kind": "pipx"}
+    py = os.path.basename(sys.executable) or "python3"
+    return {"kind": "manual", "command": f"{py} -m pip install --upgrade witbitz-code=={version}"}
+
+
+class Updates:
+    """The page's update row. `fetch_text(url)` → the installer's text; `run` and `launch` are injected for tests."""
+
+    def __init__(self, *, fetch_text: Callable[[str], Awaitable[str]], install_info: Callable[[], dict] = uninstall.pipx_install,
+                 run: Callable[[list], Any] | None = None, launch: Callable[[list], Any] | None = None,
+                 current: str = __version__, now: Callable[[], float] = time.monotonic) -> None:
+        self._fetch, self._info, self._now = fetch_text, install_info, now
+        self._run = run or (lambda argv: subprocess.run(argv, capture_output=True, text=True, check=False))
+        self._launch = launch or _launch_visible
+        self.current = current
+        self.latest: str | None = None
+        self.checked_at = -1e18
+        self.why = ""
+        self.restart = False  # set after a pipx update: ui.run starts this manager again on its way out
+
+    async def check(self, force: bool = False) -> None:
+        if not force and self._now() - self.checked_at < CHECK_EVERY_S:
+            return
+        self.checked_at = self._now()
+        try:
+            v = parse_pin(await self._fetch(INSTALLER_URL))
+            if v:
+                self.latest, self.why = v, ""
+            else:
+                self.why = "could not read the released version"
+        except Exception as e:  # noqa: BLE001 — offline is not a failure of the page
+            self.why = f"could not check for updates ({type(e).__name__})"
+
+    def status(self) -> dict:
+        avail = bool(self.latest and newer(self.latest, self.current))
+        out: dict = {"current": self.current, "latest": self.latest, "available": avail}
+        if avail:
+            out.update(how(self._info(), self.latest or ""))
+        if self.why:
+            out["why"] = self.why
+        return out
+
+    async def update(self) -> dict:
+        await self.check(force=True)
+        st = self.status()
+        if not st["available"]:
+            return {"ok": False, "why": self.why or f"witbitz-code {self.current} is the released version"}
+        v = st["latest"]
+        if st["kind"] == "installer":
+            self._launch(["powershell.exe", "-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", f"irm {INSTALLER_URL} | iex"])
+            return {"ok": True, "kind": "installer", "message": f"The installer is updating witbitz-code to {v} in its own window; this page opens again when it is done."}
+        if st["kind"] == "pipx":
+            r = self._run(["pipx", "install", "--force", f"witbitz-code=={v}"])
+            if getattr(r, "returncode", 1) != 0:
+                return {"ok": False, "why": ("pipx: " + ((getattr(r, "stderr", "") or getattr(r, "stdout", "") or "").strip().splitlines() or ["failed"])[-1])[:200]}
+            self.restart = True
+            return {"ok": True, "kind": "pipx", "message": f"Updated to {v} — witbitz-code starts again in a moment."}
+        return {"ok": False, "kind": "manual", "why": "Run this, then start witbitz-code again: " + st["command"]}
+
+
+def _launch_visible(argv: list) -> None:
+    """Windows: a console window of its own, so the person sees the installer work (the manager itself has no window)."""
+    flags = getattr(subprocess, "CREATE_NEW_CONSOLE", 0)
+    subprocess.Popen(argv, creationflags=flags, cwd=os.path.expanduser("~"))  # noqa: S603 — fixed argv, our own installer
+
+
+def restart_argv() -> list:
+    """The same manager again, on the freshly installed code: `python -m witbitz_code <the same arguments>`."""
+    return [sys.executable, "-m", "witbitz_code", *sys.argv[1:]]

{witbitz_code-1.7.2 → witbitz_code-1.7.4}/src/witbitz_code/ui.py

@@ -35,7 +35,7 @@ from importlib import resources
 from pathlib import Path
 from typing import Any, Awaitable, Callable
 
-from . import __version__, devicelink, link, net, ports, qr, seccheck, uitools, uninstall, winbg, wizard, wslstart
+from . import __version__, devicelink, link, net, ports, qr, seccheck, selfupdate, uitools, uninstall, winbg, wizard, wslstart
 from . import pair as pair_cmd
 from . import pairings as pp
 
@@ -128,11 +128,12 @@ class Manager:
                  login_disable: Callable[[dict], bool] = wslstart.startup_disable,
                  port_owners: Callable[[int], list] | None = None, stop_pid: Callable[[int], bool] | None = None,
                  tools: uitools.Tools | None = None, label: dict | None = None, log: deque | None = None,
-                 security: seccheck.SecurityCheck | None = None) -> None:
+                 security: seccheck.SecurityCheck | None = None, updates: selfupdate.Updates | None = None) -> None:
         self._serve, self._is_listening, self._pair, self._link = serve, is_listening, pair, link_node
         self._load, self._keys_line = load_pairings, keys_line
         self.tools = tools or uitools.Tools()
         self.security = security or seccheck.SecurityCheck()
+        self.updates = updates or selfupdate.Updates(fetch_text=_fetch_text)
         self._owners = port_owners or ports.port_owners
         self._stop_pid = stop_pid or uninstall.stop_process
         self._elsewhere_cache: tuple[float, dict | None] | None = None
@@ -214,7 +215,8 @@ class Manager:
             el = await self.elsewhere()
             if el:
                 serving = {"state": "elsewhere", "port": el["port"], "owners": el["owners"]}
-        return {"version": __version__, "computer": self.label, "paired": paired, "serving": serving, "pair": pair,
+        asyncio.ensure_future(self.updates.check())  # at most every few hours (selfupdate.CHECK_EVERY_S); never waited for
+        return {"version": __version__, "update": self.updates.status(), "computer": self.label, "paired": paired, "serving": serving, "pair": pair,
                 "login": self.login(), "busy": self.busy, "background": self.background,
                 "tools": await asyncio.to_thread(self.tools.status), "security": self.security.peek(), "log": list(self.log)[-14:]}
 
@@ -398,6 +400,14 @@ class Manager:
             asyncio.get_running_loop().call_later(0.3, self.quit_event.set)  # after this answer reaches the page
         return {"ok": True}
 
+    async def update(self) -> dict:
+        """The page's Update: the released version (selfupdate.py). After a pipx update this manager stops and ui.run
+        starts it again on the new code; the Windows installer stops and reopens it itself."""
+        out = await self.updates.update()
+        if out.get("ok") and self.updates.restart:
+            await self.quit()
+        return out
+
     async def shutdown(self) -> None:
         if self.pair_task and not self.pair_task.done():
             self.pair_task.cancel()
@@ -536,6 +546,7 @@ class Server:
             "/api/unpair": lambda: self.m.unpair(str(data.get("account") or "")),
             "/api/login": lambda: self.m.set_login(bool(data.get("on"))),
             "/api/quit": self.m.quit,
+            "/api/update": self.m.update,
             "/api/tools/install": self.m.tools.install,
             "/api/security/fix": lambda: self.m.security.fix(str(data.get("id") or "")),
         }
@@ -556,6 +567,22 @@ class Server:
 
 
 # ── the command ───────────────────────────────────────────────────────────────────────────────────────────────────────
+async def _fetch_text(url: str) -> str:
+    async with net.new_client() as c:
+        r = await c.get(url, headers={"cache-control": "no-store"}, timeout=20)
+        r.raise_for_status()
+        return r.text
+
+
+RESUME_ENV = "WITBITZ_UI_RESUME"  # "<port>:<token>" — a restart after an update keeps the page's address and its sign-in
+
+
+def _resume() -> tuple[int, str] | None:
+    v = os.environ.pop(RESUME_ENV, "")
+    port, _, token = v.partition(":")
+    return (int(port), token) if port.isdigit() and len(token) >= 16 else None
+
+
 def _read_lock() -> dict:
     try:
         d = json.loads(lock_path().read_text(encoding="utf-8"))
@@ -599,16 +626,17 @@ async def run(args: list[str], *, serve: Callable[..., Awaitable[int]], is_liste
     m.background = background
     stop = asyncio.Event()
     m.quit_event = stop
-    srv = Server(m)
+    resume = _resume()
+    srv = Server(m, token=resume[1] if resume else None)
     try:
-        await srv.start()
+        await srv.start(*([resume[0]] if resume else []))
         pp.write_private(lock_path(), json.dumps({"port": srv.port, "token": srv.token, "pid": os.getpid()}) + "\n")
         print(f"witbitz-code: {m.label['label']} — open {srv.url}", file=sys.stderr, flush=True)
         print("witbitz-code: running in the background — Quit on the page stops it" if background else
               "witbitz-code: keep this window open (closing it stops witbitz-code). Ctrl-C stops it.", file=sys.stderr, flush=True)
         if m.pairings():
             await m.start_serving()
-        if not no_browser and not open_browser(srv.url):
+        if not resume and not no_browser and not open_browser(srv.url):
             print("witbitz-code: open the address above in your browser", file=sys.stderr, flush=True)
         loop = asyncio.get_running_loop()
         import signal  # noqa: PLC0415
@@ -628,3 +656,7 @@ async def run(args: list[str], *, serve: Callable[..., Awaitable[int]], is_liste
         except OSError:
             pass
         sys.stderr = old_err
+        if m.updates.restart:  # updated by pipx: the same manager again, on the new code, at the same page address
+            os.environ[RESUME_ENV] = f"{srv.port}:{srv.token}"
+            print("witbitz-code: updated — starting again", file=sys.stderr, flush=True)
+            os.execv(sys.executable, selfupdate.restart_argv())

{witbitz_code-1.7.2 → witbitz_code-1.7.4}/src/witbitz_code/ui_static/app.js

@@ -96,6 +96,7 @@ function render(s) {
   // Windows, no window (winbg.py): nothing to keep open — Quit is how it stops
   $('footerText').textContent = s.background ? 'runs in the background — Start menu → Witbitz Code opens this page' : 'keep its window open — closing it stops witbitz-code'
   show($('quit'), !!s.background)
+  renderUpdate(s.update)
   renderTools(s.tools, paired)
   renderSecurity(s.security)
 
@@ -139,6 +140,32 @@ function accountOf() {
   return pick || null
 }
 
+// A released version newer than this one (selfupdate.py): the version the installer pins. Update runs that installer
+// again on Windows, pipx elsewhere; anything else shows the command.
+let updating = '', updatingFrom = ''
+function renderUpdate(u) {
+  const card = $('updateCard')
+  if (updating && u && u.current !== updatingFrom) { updating = ''; note(`Updated to ${u.current} ✓`, 'ok') }
+  if (updating) { show(card, true); show($('update'), false); $('updateText').textContent = updating; return }
+  if (!u || !u.available) return show(card, false)
+  show(card, true)
+  $('updateTitle').textContent = `witbitz-code ${u.latest} is ready`
+  $('updateText').textContent = `This computer runs ${u.current}.` + (u.kind === 'manual' ? ' Run this in a terminal, then start witbitz-code again:' : ' Update installs it and starts witbitz-code again — Code in Spaces reconnects by itself.')
+  show($('updateCmd'), u.kind === 'manual')
+  $('updateCmd').textContent = u.command || ''
+  show($('update'), u.kind !== 'manual')
+  $('update').disabled = !!state.busy
+}
+
+async function update() {
+  $('update').disabled = true
+  try {
+    const r = await api('/api/update', {})
+    if (r && r.ok) { updatingFrom = state.version; updating = r.message || 'Updating…'; note(updating, 'ok') } else note((r && r.why) || 'The update did not run.', 'bad')
+  } catch (e) { note(e.message, 'bad') }
+  await refresh()
+}
+
 // setup's Tools step, on the page (uitools.py): what is missing, what Install runs, its progress.
 function renderTools(t, paired) {
   if (!t) return show($('toolsCard'), false)
@@ -213,6 +240,7 @@ async function quit() {
 
 document.addEventListener('DOMContentLoaded', () => {
   $('quit').onclick = quit
+  $('update').onclick = update
   $('toolsInstall').onclick = () => act('/api/tools/install', {}, 'Install them now? Windows may ask once to allow an installer.')
   $('pair').onclick = () => act('/api/pair', {})
   $('start').onclick = () => act('/api/serve', { on: true })

{witbitz_code-1.7.2 → witbitz_code-1.7.4}/src/witbitz_code/ui_static/index.html

@@ -30,6 +30,13 @@
     <p id="note" class="note" hidden></p>
   </section>
 
+  <section class="card" id="updateCard" hidden>
+    <h2 id="updateTitle">An update is ready</h2>
+    <p id="updateText" class="muted"></p>
+    <pre id="updateCmd" class="cmd" hidden></pre>
+    <div class="actions"><button id="update" type="button" hidden>Update</button></div>
+  </section>
+
   <section class="card" id="pairCard" hidden>
     <h2>Pair with your Spaces account</h2>
     <ol class="steps">

{witbitz_code-1.7.2 → witbitz_code-1.7.4/src/witbitz_code.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: witbitz-code
-Version: 1.7.2
+Version: 1.7.4
 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.7.2 → witbitz_code-1.7.4}/src/witbitz_code.egg-info/SOURCES.txt

@@ -41,6 +41,7 @@ src/witbitz_code/relay.py
 src/witbitz_code/remind.py
 src/witbitz_code/seccheck.py
 src/witbitz_code/seen.py
+src/witbitz_code/selfupdate.py
 src/witbitz_code/tinfoil_read.py
 src/witbitz_code/tools_catalog.json
 src/witbitz_code/tools_probe.py
@@ -91,6 +92,7 @@ tests/test_registry.py
 tests/test_relay_codec.py
 tests/test_remind.py
 tests/test_seccheck.py
+tests/test_selfupdate.py
 tests/test_setup.py
 tests/test_tools_probe.py
 tests/test_toolsetup.py

{witbitz_code-1.7.2 → witbitz_code-1.7.4}/tests/test_confidential.py

@@ -110,7 +110,7 @@ class FakeNet:
     def handler(self, req: httpx.Request):
         if "googleapis.com/service_accounts" in str(req.url):
             return httpx.Response(200, json=self.meta["googleJwks"])
-        self.calls.append({"url": str(req.url), "headers": dict(req.headers), "body": req.content.decode("utf-8")})
+        self.calls.append({"url": str(req.url), "headers": dict(req.headers), "raw": list(req.headers.raw), "body": req.content.decode("utf-8")})
         if self.status != 200:
             return httpx.Response(self.status, json={"error": {"message": "upstream said no"}})
         data = self.stream.encode("utf-8")
@@ -176,6 +176,20 @@ def test_a_confidential_answer_streams_through_and_the_receipt_verifies_on_the_r
     with_proxy(t)
 
 
+@needs_fixture
+def test_one_content_type_goes_upstream_whatever_case_opencode_sends_it():
+    # 2026-10-17: OpenCode sends "Content-Type"; the proxy forwarded it and added its own "content-type", and TrustedRouter
+    # refused every confidential call with two (a small one 400 "could not read request", a large one closed mid-upload —
+    # an empty httpx ReadError the owner saw as "could not reach TrustedRouter ()").
+    async def t(post, net, _p):
+        r = await post(SAY_OK, {"Content-Type": "application/json", "X-Inference-Receipt": "from-the-caller"})
+        assert r.status_code == 200
+        names = [k.decode().lower() for k, _v in net.calls[0]["raw"]]
+        assert names.count("content-type") == 1, names
+        assert names.count("x-inference-receipt") == 1 and net.calls[0]["headers"]["x-inference-receipt"] != "from-the-caller"
+    with_proxy(t)
+
+
 @needs_fixture
 def test_a_receipt_that_does_not_match_ends_the_step_with_an_error_and_no_tool_runs():
     meta, stream, _ = fixture()

witbitz_code-1.7.4/tests/test_selfupdate.py

@@ -0,0 +1,94 @@
+"""Update from the page (selfupdate.py): the version the RELEASED installer pins, and the way this copy was installed."""
+
+import asyncio
+from pathlib import Path
+from types import SimpleNamespace
+
+from witbitz_code import selfupdate as su
+
+REPO = Path(__file__).resolve().parents[3]
+
+
+def run(coro):
+    return asyncio.run(coro)
+
+
+def script(v):
+    return f"$ErrorActionPreference = 'Stop'\n  $WitbitzCode = '{v}'\n  $Git = '2.47.1'\n"
+
+
+def updates(pin="1.7.4", kind="pipx", current="1.7.3", rc=0, err=""):
+    seen = {"run": [], "launch": [], "fetch": 0}
+
+    async def fetch(url):
+        seen["fetch"] += 1
+        assert url == su.INSTALLER_URL
+        if isinstance(pin, Exception):
+            raise pin
+        return script(pin)
+    u = su.Updates(fetch_text=fetch, install_info=lambda: {"kind": kind}, current=current,
+                   run=lambda argv: seen["run"].append(argv) or SimpleNamespace(returncode=rc, stderr=err, stdout=""),
+                   launch=lambda argv: seen["launch"].append(argv))
+    return u, seen
+
+
+def test_the_pin_is_read_from_the_real_installer_as_it_is_written():
+    text = (REPO / "spaces" / "public" / "code.ps1").read_text(encoding="utf-8")
+    v = su.parse_pin(text)
+    assert v and v.count(".") == 2, "code.ps1 must keep its one $WitbitzCode = 'x.y.z' line — the page reads it"
+    assert su.parse_pin("$WitbitzCode = \"1.2.3\"") is None and su.parse_pin("no pin here") is None
+
+
+def test_newer_compares_numbers_not_text():
+    assert su.newer("1.7.10", "1.7.9") and su.newer("2.0.0", "1.9.9")
+    assert not su.newer("1.7.3", "1.7.3") and not su.newer("1.7.2", "1.7.3") and not su.newer("x", "1.0.0")
+
+
+def test_nothing_offered_when_this_is_the_released_version_or_newer():
+    for pin in ("1.7.3", "1.7.2"):
+        u, _ = updates(pin=pin)
+        run(u.check())
+        assert u.status()["available"] is False
+
+
+def test_offline_is_a_reading_not_a_failure_and_it_asks_at_most_every_few_hours():
+    u, seen = updates(pin=OSError("down"))
+    run(u.check()); run(u.check())
+    assert seen["fetch"] == 1 and u.status() == {"current": "1.7.3", "latest": None, "available": False, "why": "could not check for updates (OSError)"}
+
+
+def test_pipx_installs_exactly_the_released_version_then_asks_for_a_restart(monkeypatch):
+    monkeypatch.setattr(su.shutil, "which", lambda n: "/usr/bin/pipx")
+    u, seen = updates()
+    run(u.check())
+    assert u.status() == {"current": "1.7.3", "latest": "1.7.4", "available": True, "kind": "pipx"}
+    r = run(u.update())
+    assert r["ok"] and seen["run"] == [["pipx", "install", "--force", "witbitz-code==1.7.4"]] and u.restart
+
+
+def test_a_failed_pipx_install_says_why_and_does_not_restart(monkeypatch):
+    monkeypatch.setattr(su.shutil, "which", lambda n: "/usr/bin/pipx")
+    u, _ = updates(rc=1, err="ERROR: No matching distribution found for witbitz-code==1.7.4")
+    r = run(u.update())
+    assert not r["ok"] and "No matching distribution" in r["why"] and not u.restart
+
+
+def test_the_windows_install_runs_the_released_installer_again_in_a_window_of_its_own():
+    u, seen = updates(kind="windows-installer")
+    r = run(u.update())
+    assert r["ok"] and r["kind"] == "installer" and not u.restart and not seen["run"]
+    assert seen["launch"] == [["powershell.exe", "-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", f"irm {su.INSTALLER_URL} | iex"]]
+
+
+def test_any_other_install_is_shown_the_command_never_run():
+    u, seen = updates(kind="pip")
+    run(u.check())
+    st = u.status()
+    assert st["kind"] == "manual" and st["command"].endswith("-m pip install --upgrade witbitz-code==1.7.4")
+    r = run(u.update())
+    assert not r["ok"] and st["command"] in r["why"] and not seen["run"] and not seen["launch"]
+
+
+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"]

{witbitz_code-1.7.2 → witbitz_code-1.7.4}/tests/test_ui.py

@@ -276,3 +276,34 @@ def test_in_wsl_the_page_opener_is_waited_for(monkeypatch):
     assert ui.open_browser("http://127.0.0.1:4291/?t=x") is True
     argv, kw = calls[0]
     assert argv == ["wslview", "http://127.0.0.1:4291/?t=x"] and kw["timeout"] == 15
+
+
+def test_the_page_offers_the_released_update_and_a_pipx_update_ends_this_manager_for_its_restart(monkeypatch):
+    from witbitz_code import selfupdate as su
+    monkeypatch.setattr(su.shutil, "which", lambda n: "/usr/bin/pipx")
+    ran = []
+
+    async def fetch(_u):
+        return "$WitbitzCode = '9.9.9'\n"
+    w = World(pairings=[DESK])
+    m = w.manager()
+    m.updates = su.Updates(fetch_text=fetch, install_info=lambda: {"kind": "pipx"}, current="1.0.0",
+                           run=lambda argv: ran.append(argv) or SimpleNamespace(returncode=0, stderr="", stdout=""))
+
+    async def t():
+        import httpx
+        m.quit_event = asyncio.Event()
+        srv, base = await with_server(m)
+        try:
+            async with httpx.AsyncClient() as c:
+                await m.updates.check()
+                s = (await c.get(base + "/api/status", headers=authed(srv))).json()
+                assert s["update"] == {"current": "1.0.0", "latest": "9.9.9", "available": True, "kind": "pipx"}
+                r = (await c.post(base + "/api/update", json={}, headers=authed(srv, **{"content-type": "application/json"}))).json()
+                assert r["ok"] and ran == [["pipx", "install", "--force", "witbitz-code==9.9.9"]]
+            await asyncio.wait_for(m.quit_event.wait(), 2)
+            assert m.updates.restart
+        finally:
+            await m.shutdown()
+            await srv.close()
+    run(t())