witbitz-code 1.9.2__tar.gz → 1.9.4__tar.gz

{witbitz_code-1.9.2/src/witbitz_code.egg-info → witbitz_code-1.9.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: witbitz-code
-Version: 1.9.2
+Version: 1.9.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.9.2 → witbitz_code-1.9.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "witbitz-code"
-version = "1.9.2"
+version = "1.9.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.9.2 → witbitz_code-1.9.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.9.2"
+__version__ = "1.9.4"

{witbitz_code-1.9.2 → witbitz_code-1.9.4}/src/witbitz_code/confidential.py

@@ -261,6 +261,28 @@ def without_words(frame: str) -> str:
     return f"data: {dumps({**ev, 'choices': [{**ch, 'delta': rest}, *ev['choices'][1:]]})}\n\n"
 
 
+# The confidential default (⇄ tools/code-confidential.mjs CONFIDENTIAL_DEFAULT): what answers when a pick has no verified-enclave
+# route right now. The note says so once per session — a Code task makes many calls.
+CONFIDENTIAL_DEFAULT = "deepseek/deepseek-v4.1-flash"
+_NOTED: dict = {}
+
+
+def fallback_note(frm: str, by: str, session_id: str = "") -> str:
+    if not frm:
+        return ""
+    k = session_id + "\0" + frm
+    if k in _NOTED:
+        return ""
+    _NOTED[k] = True
+    if len(_NOTED) > 500:
+        _NOTED.pop(next(iter(_NOTED)))
+    return f"\n\n_Answered by {by} — {frm} isn't available confidentially right now._"
+
+
+def note_frame(note: str, model: str) -> str:
+    return "data: " + dumps({"id": "witbitz-note", "object": "chat.completion.chunk", "model": model, "choices": [{"index": 0, "delta": {"content": note}}]}) + "\n\n"
+
+
 def completion_of(events: list, model: str) -> dict:
     """The streamed events as one chat.completion — for a caller that asked without `stream`."""
     content = reasoning = ""
@@ -652,7 +674,10 @@ class ConfidentialProxy:
             except Exception:  # noqa: BLE001 — progress must never fail a call
                 pass
 
+        fell = {"from": ""}  # the pick's label when TrustedRouter had no verified-enclave route for it and the default answered
+
         async def once(words_shown: bool = False) -> None:
+            nonlocal body, conf, label
             ends = self._proof_ends.get(body["model"])
             hold = attempt["n"] > 1 or (ends is not None and self._now() / 1000 >= ends - HOLD_BEFORE_LAPSE_SEC)
             n = self._nonce()
@@ -670,6 +695,16 @@ class ConfidentialProxy:
                     used = allowance_used(up.status_code, text)
                     if used:
                         raise used
+                    # No verified-enclave route for the pick (2026-10-20, ⇄ tools/code-confidential.mjs): refused BEFORE any upstream
+                    # saw the request — the same request goes again as the confidential default, attested and checked, once.
+                    if (up.status_code == 400 and "no route candidates" in text.lower() and not fell["from"] and body.get("model") != CONFIDENTIAL_DEFAULT
+                            and CONFIDENTIAL_DEFAULT in self.models and not res.headers_sent):
+                        fell["from"] = conf["label"]
+                        self.log(f"code-confidential: {body['model']} has no verified-enclave route now → {CONFIDENTIAL_DEFAULT} answers")
+                        body = {**body, "model": CONFIDENTIAL_DEFAULT}
+                        conf = self.models[CONFIDENTIAL_DEFAULT]
+                        label = f"{conf['label']} (confidential)"
+                        return await once(words_shown)
                     if res.headers_sent:
                         raise Refusal(502, f"{label}: TrustedRouter answered {up.status_code} when asked again ({text[:160]})", "upstream_error")
                     await res.head(up.status_code, {"content-type": up.headers.get("content-type", "application/json")})
@@ -710,15 +745,25 @@ class ConfidentialProxy:
             exp = ((v.get("claims") or {}).get("upstream") or {}).get("verification_expires_at")
             if isinstance(exp, (int, float)):
                 self._proof_ends[body["model"]] = exp
+            note = fallback_note(fell["from"], conf["label"], session_id)
             if wants_stream:
+                noted = not note
                 for f in answer.held():
+                    if not noted and re.search(r'"finish_reason":"|^data: \[DONE\]', f, re.M):
+                        await res.write(note_frame(note, body["model"]))  # the note goes in before the answer ends
+                        noted = True
                     out = without_words(f) if words_shown else f
                     if out:
                         await res.write(out)
+                if not noted:
+                    await res.write(note_frame(note, body["model"]))
                 await res.end()
                 return
             await res.head(200, {"content-type": "application/json"})
-            await res.end(dumps(completion_of(answer.events(), body["model"])))
+            done = completion_of(answer.events(), body["model"])
+            if note and done.get("choices") and done["choices"][0].get("message") is not None:
+                done["choices"][0]["message"]["content"] = (done["choices"][0]["message"].get("content") or "") + note
+            await res.end(dumps(done))
 
         try:
             if not conf.get("vision"):

{witbitz_code-1.9.2 → witbitz_code-1.9.4}/src/witbitz_code/ui.py

@@ -382,6 +382,8 @@ class Manager:
                 await self.start_serving()
             return {"ok": False, "why": next((s for s in reversed(said) if "✖" in s or "pass --account" in s), "could not unpair").replace("witbitz-code: ", "", 1)}
         self.pair_state = {"state": "idle", "n": self.pair_state.get("n", 0)}
+        if self.pairings():  # one account of several unpaired: the others stay reachable (the owner, 2026-10-22: several accounts)
+            await self.start_serving()
         return {"ok": True}
 
     async def set_login(self, on: bool) -> dict:

{witbitz_code-1.9.2 → witbitz_code-1.9.4}/src/witbitz_code/ui_static/app.js

@@ -60,6 +60,13 @@ function render(s) {
     const who = document.createElement('div'); who.className = 'who'; who.textContent = `${p.name} → ${p.account || 'your account'}`
     const keys = document.createElement('div'); keys.className = 'keys'; keys.textContent = p.keys || ''
     li.append(who, keys)
+    // SEVERAL ACCOUNTS (the owner, 2026-10-22: "can we make it so it can handle multiple accounts?"): each one leaves on its own
+    if (s.paired.length > 1 && p.account) {
+      const out = document.createElement('button'); out.type = 'button'; out.className = 'ghost danger small'; out.textContent = 'Unpair ' + p.account
+      out.disabled = !!s.busy
+      out.onclick = () => act('/api/unpair', { account: p.account }, `Unpair ${p.account}? Code in that account stops reaching this computer; the other accounts keep it.`)
+      li.append(out)
+    }
     list.append(li)
   }
 
@@ -70,8 +77,10 @@ function render(s) {
   $('start').textContent = run === 'elsewhere' ? 'Run it here' : 'Start'
   show($('stop'), paired && run !== 'stopped')
   show($('pairAgain'), paired && !waiting)
+  show($('pairAdd'), paired && !waiting)
   show($('unpair'), paired && !waiting)
-  for (const id of ['pair', 'start', 'stop', 'pairAgain', 'unpair', 'pairCancel', 'pairRetry']) $(id).disabled = busy
+  $('unpair').textContent = s.paired.length > 1 ? 'Unpair all' : 'Unpair'
+  for (const id of ['pair', 'start', 'stop', 'pairAgain', 'pairAdd', 'unpair', 'pairCancel', 'pairRetry']) $(id).disabled = busy
 
   show($('pairCard'), waiting || s.pair.state === 'failed')
   if (waiting) {
@@ -121,7 +130,7 @@ async function refresh(fresh = false) {
 
 async function act(path, body, ask) {
   if (ask && !window.confirm(ask)) return false
-  for (const id of ['pair', 'start', 'stop', 'pairAgain', 'unpair']) $(id).disabled = true
+  for (const id of ['pair', 'start', 'stop', 'pairAgain', 'pairAdd', 'unpair']) $(id).disabled = true
   let ok = false
   try {
     const r = await api(path, body)
@@ -257,7 +266,7 @@ async function quit() {
   quitting = true
   try { await api('/api/quit', {}) } catch { /* it is going away */ }
   note('Witbitz Code stopped. Start menu → Witbitz Code starts it again.', 'bad')
-  for (const id of ['pair', 'start', 'stop', 'pairAgain', 'unpair', 'quit']) $(id).disabled = true
+  for (const id of ['pair', 'start', 'stop', 'pairAgain', 'pairAdd', 'unpair', 'quit']) $(id).disabled = true
 }
 
 document.addEventListener('DOMContentLoaded', () => {
@@ -268,17 +277,25 @@ document.addEventListener('DOMContentLoaded', () => {
   $('pair').onclick = () => act('/api/pair', {})
   $('start').onclick = () => act('/api/serve', { on: true })
   $('stop').onclick = () => act('/api/serve', { on: false }, 'Stop? Code in Spaces will not reach this computer until you start it again.')
-  $('unpair').onclick = () => {
-    const account = accountOf()
-    if (account === null) return
-    act('/api/unpair', { account }, 'Unpair this computer? It leaves your Spaces account, its coding keys go back, and Code on every device drops it.')
+  $('unpair').onclick = async () => {
+    const accounts = ((state && state.paired) || []).map((p) => p.account).filter(Boolean)
+    if (accounts.length > 1) { // every account, one at a time (the command unpairs one account per call)
+      if (!window.confirm(`Unpair all ${accounts.length} accounts? Code in each of them stops reaching this computer, and its coding keys go back.`)) return
+      for (const account of accounts) if (!(await act('/api/unpair', { account }))) return
+      return
+    }
+    act('/api/unpair', { account: accounts[0] || '' }, 'Unpair this computer? It leaves your Spaces account, its coding keys go back, and Code on every device drops it.')
   }
+
   $('pairAgain').onclick = async () => {
     const account = accountOf()
     if (account === null) return
     if (!window.confirm('Pair again? This computer is unpaired first, then shows a new code to scan.')) return
     if (await act('/api/unpair', { account })) act('/api/pair', {})
   }
+  // ANOTHER ACCOUNT ON THIS COMPUTER: a new code beside the pairings there are (pairings.json holds one per account, on the
+  // same OpenCode); nothing is unpaired. Code here pauses while the code is up and comes back when it is scanned or cancelled.
+  $('pairAdd').onclick = () => act('/api/pair', {}, 'Add another account? A new code appears — scan it from the other account: Code in Spaces → Computers → Add a computer. Code on this computer pauses until it is scanned or cancelled.')
   $('pairCancel').onclick = () => act('/api/pair/cancel', {})
   $('pairRetry').onclick = () => act('/api/pair', {})
   $('login').onchange = (e) => act('/api/login', { on: e.target.checked })

{witbitz_code-1.9.2 → witbitz_code-1.9.4}/src/witbitz_code/ui_static/index.html

@@ -25,6 +25,7 @@
       <button id="start" type="button" hidden>Start</button>
       <button id="stop" type="button" class="ghost" hidden>Stop</button>
       <button id="pairAgain" type="button" class="ghost" hidden>Pair again</button>
+      <button id="pairAdd" type="button" class="ghost" hidden>Add another account</button>
       <button id="unpair" type="button" class="ghost danger" hidden>Unpair</button>
     </div>
     <p id="note" class="note" hidden></p>

{witbitz_code-1.9.2 → witbitz_code-1.9.4/src/witbitz_code.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: witbitz-code
-Version: 1.9.2
+Version: 1.9.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.9.2 → witbitz_code-1.9.4}/tests/test_codekeys.py

@@ -10,7 +10,7 @@ import json
 
 import httpx
 import pytest
-from conftest import requires_node, run_node
+from conftest import requires_server_keys, requires_node, run_node
 
 from witbitz_code import codekeys, confidential as cf, models as mdl
 from witbitz_code.payers import SessionPayers
@@ -47,6 +47,7 @@ def test_a_secret_the_server_seals_to_this_computer_opens_here_and_nowhere_else(
 
 
 @requires_node
+@requires_server_keys
 def test_this_computers_signature_is_the_one_the_server_accepts_and_only_for_its_op():
     ident = codekeys.new_identity()
     entry = {**ident, "keyId": f"{U}.{K}"}

{witbitz_code-1.9.2 → witbitz_code-1.9.4}/tests/test_confidential.py

@@ -410,3 +410,35 @@ def test_the_months_allowance_used_is_a_402_that_says_so_never_a_429_opencode_wo
         with_proxy(t, net=LimitNet(meta, stream.decode("utf-8")), models=models)
     assert cf.allowance_used(429, '{"error":{"message":"rate limited"}}') is None, "a real rate limit stays a rate limit"
     assert cf.allowance_used(400, json.dumps(SPEND_LIMIT)) is None
+
+
+class NoRouteThenReplay(FakeNet):
+    """TrustedRouter refuses any model but the default ("No route candidates" — before any upstream sees it); the default
+    answers with the captured stream."""
+
+    def handler(self, req: httpx.Request):
+        if "googleapis.com/service_accounts" not in str(req.url) and json.loads(req.content.decode("utf-8")).get("model") != cf.CONFIDENTIAL_DEFAULT:
+            self.calls.append({"url": str(req.url), "headers": dict(req.headers), "raw": list(req.headers.raw), "body": req.content.decode("utf-8")})
+            return httpx.Response(400, json={"error": {"message": "No route candidates match the requested provider filters"}})
+        return super().handler(req)
+
+
+@needs_fixture
+def test_a_pick_with_no_verified_enclave_route_is_answered_by_the_default_with_one_note_per_session():
+    meta, stream, request = fixture()
+    net = NoRouteThenReplay(meta, stream.decode("utf-8"))
+    logs = []
+    glm = {**SAY_OK, "model": "z-ai/glm-5.3"}
+
+    async def t(post, net_, _p):
+        r = await post(glm, {"x-session-id": "ses_fb"})
+        text = r.text
+        assert [json.loads(c["body"])["model"] for c in net.calls] == ["z-ai/glm-5.3", "deepseek/deepseek-v4.1-flash"], "the pick, then the default — once"
+        assert net.calls[1]["body"].encode() == request, "the same request, only the model changed — the receipt signs it"
+        assert '"content":"OK"' in text
+        assert "Answered by DeepSeek V4.1 Flash — GLM 5.3 isn't available confidentially right now." in text
+        assert text.index("Answered by") < text.index("[DONE]")
+        again = (await post(glm, {"x-session-id": "ses_fb"})).text
+        assert "Answered by" not in again and '"content":"OK"' in again, "said once per session"
+        assert any("has no verified-enclave route now" in line for line in logs)
+    with_proxy(t, net=net, log=logs.append)

{witbitz_code-1.9.2 → witbitz_code-1.9.4}/tests/test_pair_flows.py

@@ -277,18 +277,18 @@ def test_status_output_is_json_free_of_secrets_even_for_js_written_files():
 
 
 def test_rename_relabels_the_computer_in_the_account_and_here_with_no_scan(monkeypatch):
-    # WSL's pairing and Windows' were two "AlonASUS" in Code (the owner, 2026-10-09); setup renames WSL's "… (WSL)"
-    api = MockApi(docs={"computers": with_computer(None, "cmp_wsl_1", {"name": "AlonASUS", "relay": RELAY, "secret": SECRET}, 500)})
-    entry = {"account": "a@x.com", "idx": IDX, "computerId": "cmp_wsl_1", "secret": SECRET, "name": "AlonASUS", "relay": RELAY,
+    # WSL's pairing and Windows' were two "my-laptop" in Code (the owner, 2026-10-09); setup renames WSL's "… (WSL)"
+    api = MockApi(docs={"computers": with_computer(None, "cmp_wsl_1", {"name": "my-laptop", "relay": RELAY, "secret": SECRET}, 500)})
+    entry = {"account": "a@example.com", "idx": IDX, "computerId": "cmp_wsl_1", "secret": SECRET, "name": "my-laptop", "relay": RELAY,
              "opencodeUrl": "http://127.0.0.1:4096"}
     pp.write_pairings({"v": 1, "pairings": [entry]})
-    assert run(pair.rename(entry, "AlonASUS (WSL)", call=api.call, out=lambda m: None, err=lambda m: None)) is True
+    assert run(pair.rename(entry, "my-laptop (WSL)", call=api.call, out=lambda m: None, err=lambda m: None)) is True
     reg = norm_registry(api.plain("computers"))
-    assert reg["computers"]["cmp_wsl_1"]["name"] == "AlonASUS (WSL)" and reg["computers"]["cmp_wsl_1"]["secret"] == SECRET
-    assert [p["name"] for p in pp.read_pairings()["pairings"]] == ["AlonASUS (WSL)"]
+    assert reg["computers"]["cmp_wsl_1"]["name"] == "my-laptop (WSL)" and reg["computers"]["cmp_wsl_1"]["secret"] == SECRET
+    assert [p["name"] for p in pp.read_pairings()["pairings"]] == ["my-laptop (WSL)"]
     refused = MockApi(read_status=500)
-    assert run(pair.rename({**entry, "name": "AlonASUS (WSL)"}, "x", call=refused.call, out=lambda m: None, err=lambda m: None)) is False
-    assert [p["name"] for p in pp.read_pairings()["pairings"]] == ["AlonASUS (WSL)"], "nothing renamed here when the account refused"
+    assert run(pair.rename({**entry, "name": "my-laptop (WSL)"}, "x", call=refused.call, out=lambda m: None, err=lambda m: None)) is False
+    assert [p["name"] for p in pp.read_pairings()["pairings"]] == ["my-laptop (WSL)"], "nothing renamed here when the account refused"
 
 
 def test_a_new_pairing_on_wsl_is_named_for_wsl(monkeypatch):
@@ -296,8 +296,8 @@ def test_a_new_pairing_on_wsl_is_named_for_wsl(monkeypatch):
 
     from witbitz_code import ports
 
-    monkeypatch.setattr(socket, "gethostname", lambda: "AlonASUS")
+    monkeypatch.setattr(socket, "gethostname", lambda: "my-laptop")
     monkeypatch.setattr(ports, "on_wsl", lambda: True)
-    assert pp.hostname() == "AlonASUS (WSL)"
+    assert pp.hostname() == "my-laptop (WSL)"
     monkeypatch.setattr(ports, "on_wsl", lambda: False)
-    assert pp.hostname() == "AlonASUS"
+    assert pp.hostname() == "my-laptop"

{witbitz_code-1.9.2 → witbitz_code-1.9.4}/tests/test_setup.py

@@ -108,7 +108,7 @@ class Fake:
         async def pair(port):
             self.paired.append(port)
             if not any(p.get("computerId") == "c" for p in self._pairings):
-                self._pairings.append({"name": "desk", "account": "a@x.com", "opencodeUrl": f"http://127.0.0.1:{port}", "idx": {"room": "r"}, "computerId": "c"})
+                self._pairings.append({"name": "desk", "account": "a@example.com", "opencodeUrl": f"http://127.0.0.1:{port}", "idx": {"room": "r"}, "computerId": "c"})
             if self._gives:
                 self._keyed.add("c")
         async def listening(port):
@@ -213,14 +213,14 @@ def test_s_stops_setup_and_leaves_the_running_one_alone():
 def test_a_computer_removed_from_the_account_is_paired_again_and_shows_the_qr():
     # the owner, 2026-10-08: reinstalled after the computer was removed and "it does not present the QR code" — its pairing
     # and keys were still on disk, so setup said "✓ Paired" over keys the account had already taken back
-    f = Fake(pairings=[{"name": "desk", "account": "a@x.com", "opencodeUrl": "http://127.0.0.1:4096", "idx": {"room": "r"}, "computerId": "c"}], keyed={"c"})
+    f = Fake(pairings=[{"name": "desk", "account": "a@example.com", "opencodeUrl": "http://127.0.0.1:4096", "idx": {"room": "r"}, "computerId": "c"}], keyed={"c"})
     asked = []
     async def keys_state(p):
         asked.append(p["computerId"])
         return "live" if f.paired else "revoked"
     r = run(wizard.run_setup(f.deps(keys_state=keys_state, forget_keys=lambda p: f._keyed.discard(p["computerId"]))))
     assert f.paired == [4096] and r["paired"] and r["keys"] and f.served == [4096]
-    assert any('"desk" → a@x.com was removed from your Witbitz account' in line for line in f.said)
+    assert any('"desk" → a@example.com was removed from your Witbitz account' in line for line in f.said)
     assert any("scan the code below" in line for line in f.said)
     assert not any(line.startswith("   ✓ Paired") for line in f.said[:f.said.index(next(x for x in f.said if "was removed" in x))])
 
@@ -248,7 +248,7 @@ def test_windows_and_wsl_each_run_their_own_the_windows_one_moves_off_the_port_w
 
 
 def test_on_wsl_a_pairing_named_like_the_windows_computer_is_renamed_once():
-    # WSL calls itself by the Windows computer's name: Windows' and WSL's pairings were two "AlonASUS" in Code
+    # WSL calls itself by the Windows computer's name: Windows' and WSL's pairings were two "my-laptop" in Code
     f = Fake(pairings=[DESK], keyed={"c"})
     renamed = []
 

{witbitz_code-1.9.2 → witbitz_code-1.9.4}/tests/test_ui.py

@@ -11,7 +11,7 @@ import httpx
 
 from witbitz_code import ui
 
-DESK = {"name": "AlonASUS", "account": "a@x.com", "opencodeUrl": "http://127.0.0.1:4097", "idx": {"room": "r"}, "computerId": "c"}
+DESK = {"name": "my-laptop", "account": "a@example.com", "opencodeUrl": "http://127.0.0.1:4097", "idx": {"room": "r"}, "computerId": "c"}
 
 
 def run(coro):
@@ -39,11 +39,11 @@ class World:
         self.pair_calls.append(argv)
         if "--unpair" in argv:
             self.pairings = []
-            out("witbitz-code: ✓ removed \"AlonASUS\" from a@x.com — every device drops it on its next sync")
+            out("witbitz-code: ✓ removed \"my-laptop\" from a@example.com — every device drops it on its next sync")
             return 0
         await self.scan.wait()
         self.pairings = [{**DESK, "opencodeUrl": f"http://127.0.0.1:{argv[argv.index('--port') + 1]}"}]
-        out("witbitz-code: ✓ paired \"AlonASUS\" with a@x.com (pairings.json)")
+        out("witbitz-code: ✓ paired \"my-laptop\" with a@example.com (pairings.json)")
         return 0
 
     def manager(self, listening=()):
@@ -58,7 +58,7 @@ class World:
                           keys_line=keys_line, login_spec=spec, login_state=lambda s: "on" if self.login["on"] else "off",
                           login_enable=lambda s: (self.login.__setitem__("on", True), (True, ""))[1],
                           login_disable=lambda s: self.login.__setitem__("on", False) or True,
-                          label={"label": "AlonASUS", "kind": "Windows"}, log=deque(maxlen=60))
+                          label={"label": "my-laptop", "kind": "Windows"}, log=deque(maxlen=60))
 
 
 async def with_server(m):
@@ -113,8 +113,8 @@ def test_status_start_and_stop_serving_on_the_paired_port():
         try:
             async with httpx.AsyncClient() as c:
                 st = (await c.get(f"{base}/api/status", headers=authed(srv))).json()
-                assert st["computer"]["label"] == "AlonASUS" and st["serving"]["state"] == "stopped"
-                assert st["paired"] == [{"name": "AlonASUS", "account": "a@x.com", "port": 4097, "keys": "coding keys: live · models this month $1.2 of $50 · tools up to $5"}]
+                assert st["computer"]["label"] == "my-laptop" and st["serving"]["state"] == "stopped"
+                assert st["paired"] == [{"name": "my-laptop", "account": "a@example.com", "port": 4097, "keys": "coding keys: live · models this month $1.2 of $50 · tools up to $5"}]
                 assert (await c.post(f"{base}/api/serve", headers=authed(srv), json={"on": True})).json() == {"ok": True}
                 assert await until(lambda: _state(c, base, srv, "online"))
                 assert w.serves == [["--port", "4097"]], "the port this computer is paired for"
@@ -187,11 +187,11 @@ def test_a_cancelled_pairing_goes_back_to_serving_and_the_login_switch_writes_th
 
 
 def test_the_page_names_which_computer_it_controls(monkeypatch):
-    monkeypatch.setattr(ui.socket, "gethostname", lambda: "AlonASUS")
+    monkeypatch.setattr(ui.socket, "gethostname", lambda: "my-laptop")
     monkeypatch.setattr(ui.ports, "on_wsl", lambda: True)
     monkeypatch.setattr(ui.sys, "platform", "linux")
     monkeypatch.setenv("WSL_DISTRO_NAME", "UbuntuD")
-    assert ui.computer_label() == {"label": "UbuntuD (WSL) on AlonASUS", "kind": "WSL UbuntuD"}
+    assert ui.computer_label() == {"label": "UbuntuD (WSL) on my-laptop", "kind": "WSL UbuntuD"}
 
 
 def _other_window_manager(w, held):
@@ -208,7 +208,7 @@ def _other_window_manager(w, held):
 
     m = ui.Manager(serve=w.serve, is_listening=is_listening, pair=w.pair, load_pairings=lambda: list(w.pairings),
                    port_owners=lambda q: [{"pid": 19824, "cmd": "python.exe"}] if q in held else [],
-                   stop_pid=stop_pid, login_spec=lambda: None, label={"label": "AlonASUS", "kind": "Windows"}, log=deque(maxlen=60))
+                   stop_pid=stop_pid, login_spec=lambda: None, label={"label": "my-laptop", "kind": "Windows"}, log=deque(maxlen=60))
     return m, stopped
 
 
@@ -334,3 +334,58 @@ def test_opening_the_page_asks_for_a_release_again_a_status_poll_does_not():
             await m.shutdown()
             await srv.close()
     run(t())
+
+
+class TwoAccounts(World):
+    """A second account pairs beside the first (pairings.json holds one entry per account), and unpairs alone."""
+
+    async def pair(self, argv, *, link_fn=None, out=print, err=print):
+        self.pair_calls.append(argv)
+        if "--unpair" in argv:
+            who = argv[argv.index("--account") + 1] if "--account" in argv else ""
+            self.pairings = [p for p in self.pairings if who and p["account"] != who]
+            out(f"witbitz-code: ✓ removed \"my-laptop\" from {who or 'every account'}")
+            return 0
+        await self.scan.wait()
+        port = argv[argv.index("--port") + 1]
+        self.pairings = self.pairings + [{**DESK, "account": "b@example.com", "idx": {"room": "r2"}, "opencodeUrl": f"http://127.0.0.1:{port}"}]
+        out("witbitz-code: ✓ paired \"my-laptop\" with b@example.com (pairings.json)")
+        return 0
+
+
+def test_another_account_pairs_beside_the_first_and_one_unpairs_while_the_other_keeps_serving():
+    # The owner, 2026-10-22: "can we make it so it can handle multiple accounts?" — the page's Add another account
+    async def go():
+        w = TwoAccounts([DESK])
+        m = w.manager(listening={4096, 4196})
+        srv, base = await with_server(m)
+        try:
+            await m.start_serving()
+            async with httpx.AsyncClient() as c:
+                assert (await c.post(f"{base}/api/pair", headers=authed(srv), json={})).json() == {"ok": True}
+                assert w.pair_calls[-1] == ["--port", "4097"], "the same OpenCode as the first account's — nothing unpaired"
+                w.scan.set()
+                assert await until(lambda: _state(c, base, srv, "online"))
+                st = (await c.get(f"{base}/api/status", headers=authed(srv))).json()
+                assert sorted(p["account"] for p in st["paired"]) == ["a@example.com", "b@example.com"]
+                # one account leaves; the other stays paired AND reachable
+                assert (await c.post(f"{base}/api/unpair", headers=authed(srv), json={"account": "b@example.com"})).json() == {"ok": True}
+                assert w.pair_calls[-1] == ["--unpair", "--account", "b@example.com"]
+                assert [p["account"] for p in w.pairings] == ["a@example.com"]
+                assert await until(lambda: _state(c, base, srv, "online")), "serving resumes for the account that stayed"
+        finally:
+            await m.shutdown()
+            await srv.close()
+
+    run(go())
+
+
+def test_the_page_offers_another_account_and_an_unpair_per_account():
+    from pathlib import Path
+    root = Path(ui.__file__).parent / "ui_static"
+    html, js = (root / "index.html").read_text(), (root / "app.js").read_text()
+    assert 'id="pairAdd"' in html and "Add another account" in html
+    assert "show($('pairAdd'), paired && !waiting)" in js
+    assert "$('pairAdd').onclick = () => act('/api/pair', {}" in js, "a new code beside the pairings there are — no unpair first"
+    assert "if (s.paired.length > 1 && p.account)" in js and "act('/api/unpair', { account: p.account }" in js
+    assert "for (const account of accounts) if (!(await act('/api/unpair', { account }))) return" in js, "Unpair all = each account in turn"

{witbitz_code-1.9.2 → witbitz_code-1.9.4}/tests/test_uninstall.py

@@ -75,7 +75,7 @@ class Fake:
             **{"login_start": lambda: None, "menu_remove": lambda: False, "running": lambda: [], **over})  # never this machine's Windows Startup folder or Start menu
 
 
-PAIR = {"name": "desk", "account": "a@x.com", "idx": {"room": "r"}, "computerId": "c"}
+PAIR = {"name": "desk", "account": "a@example.com", "idx": {"room": "r"}, "computerId": "c"}
 
 
 def test_saying_no_changes_nothing():
@@ -207,7 +207,7 @@ def test_what_runs_witbitz_code_is_the_page_s_manager_and_the_paired_ports_owner
 
 
 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' \
+    out = '"opencode.exe","19228","Console","1","95,000 K","Running","MY-LAPTOP\\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"}]
 

{witbitz_code-1.9.2 → witbitz_code-1.9.4}/tests/test_wslstart.py

@@ -12,7 +12,7 @@ from witbitz_code import wslstart
 
 def test_the_shortcut_runs_this_distro_this_user_from_home_then_serve():
     assert wslstart.shortcut_name("UbuntuD") == "Witbitz Code (WSL UbuntuD).lnk" and wslstart.shortcut_name("") == "Witbitz Code (WSL).lnk"
-    assert wslstart.wsl_args("UbuntuD", "ubuntu", ["/home/ubuntu/.local/bin/witbitz-code"]) == "-d UbuntuD -u ubuntu --cd ~ -- /home/ubuntu/.local/bin/witbitz-code serve"
+    assert wslstart.wsl_args("UbuntuD", "ubuntu", ["/home/dana/.local/bin/witbitz-code"]) == "-d UbuntuD -u ubuntu --cd ~ -- /home/dana/.local/bin/witbitz-code serve"
     assert wslstart.wsl_args("", "a b", ["/x y/witbitz-code"]) == '-u "a b" --cd ~ -- "/x y/witbitz-code" serve'
     s = wslstart.enable_script("it's.lnk", "-d X -- /w serve")
     assert "'it''s.lnk'" in s and "$s.WindowStyle = 7" in s and "System32\\wsl.exe" in s and "[Environment]::GetFolderPath('Startup')" in s
@@ -32,7 +32,7 @@ def test_state_enable_and_disable_read_what_powershell_says():
 
 @requires_node
 def test_the_javascript_writes_the_same_shortcut():
-    cases = [["UbuntuD", "ubuntu", ["/home/ubuntu/.local/bin/witbitz-code"]], ["", "a b", ["/usr/bin/node", "/x y/witbitz-code.mjs"]]]
+    cases = [["UbuntuD", "ubuntu", ["/home/dana/.local/bin/witbitz-code"]], ["", "a b", ["/usr/bin/node", "/x y/witbitz-code.mjs"]]]
     js = run_node("""
       import { shortcutName, wslArgs, enableScript, stateScript, disableScript } from '@TOOLS@/code-wsl-start.mjs'
       OUT(INPUT.cases.map(([d, u, e]) => [shortcutName(d), wslArgs(d, u, e), enableScript(shortcutName(d), wslArgs(d, u, e)), stateScript(shortcutName(d)), disableScript(shortcutName(d))]))