witbitz-code 1.9.3__tar.gz → 1.9.5__tar.gz

{witbitz_code-1.9.3/src/witbitz_code.egg-info → witbitz_code-1.9.5}/PKG-INFO

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

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

{witbitz_code-1.9.3 → witbitz_code-1.9.5}/src/witbitz_code/cli.py

@@ -384,7 +384,7 @@ async def uninstall(args: list[str]) -> int:
             return {"ok": False, "why": "could not give this computer's coding keys back"}
         if entry:
             codekeys.forget(p["computerId"])
-        r = await acct.unpublish_computer(call=call, idx=p["idx"], computer_id=p["computerId"])
+        r = await acct.unpublish_computer(call=net.call_for(call, p.get("origin")), idx=p["idx"], computer_id=p["computerId"])
         if r.get("ok"):
             pp.write_pairings(pp.remove_pairings(pp.read_pairings(), p.get("account") or "")["doc"])
         return r

{witbitz_code-1.9.3 → witbitz_code-1.9.5}/src/witbitz_code/link.py

@@ -156,6 +156,7 @@ async def _link(life_ms, poll_s, origins, get_json, post_json, challenge, svg_pa
     out(f"  waiting up to {round(wait_s)}s for your device to seal the account to this computer…\n")
     until = time.monotonic() + wait_s
     warned = False
+    found = ""
     while time.monotonic() < until:
         await asyncio.sleep(poll_s)
         r = None
@@ -168,7 +169,7 @@ async def _link(life_ms, poll_s, origins, get_json, post_json, challenge, svg_pa
                 err(f"witbitz-code: note — {origin} has no device-link relay; ignoring it.")
                 warned = True
             if isinstance(rr, dict) and truthy(rr.get("ok")):
-                r = rr
+                r, found = rr, origin
                 break
         if r is None:
             continue  # 404 on all = not sealed yet
@@ -184,6 +185,10 @@ async def _link(life_ms, poll_s, origins, get_json, post_json, challenge, svg_pa
         if not account:
             err("witbitz-code: the reply carried no account key.")
             return None
+        # 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).
+        account["origin"] = found
         via = "link" if account["idx"] else ""
         if not account["idx"]:
             out("witbitz-code: no index pointer in the link — recovering it from your account backup… ", end="")

{witbitz_code-1.9.3 → witbitz_code-1.9.5}/src/witbitz_code/net.py

@@ -4,6 +4,7 @@ retried or cached)."""
 from __future__ import annotations
 
 import os
+import re
 from collections.abc import Awaitable, Callable
 from dataclasses import dataclass
 from typing import Any
@@ -31,10 +32,24 @@ def _json_of(r: httpx.Response) -> Any:
     return _js.parse(r.content.decode("utf-8-sig", "replace"))  # fetch's r.json(): BOM dropped, then JSON.parse
 
 
-def make_api_call(client: httpx.AsyncClient) -> ApiCall:
-    """POST {op:'state', …} to the account API, as the Spaces app would (same Origin)."""
+def app_origin(o: Any) -> str:
+    """A pairing's app address, when it is one: https and nothing but scheme://host. Else '' (the default app)."""
+    return o if isinstance(o, str) and re.fullmatch(r"https://[A-Za-z0-9.-]+(:[0-9]+)?", o) else ""
+
+
+def call_for(call: Any, origin: Any) -> Any:
+    """The same account call, speaking as the app `origin` pairs through (its rooms answer only their own app's addresses —
+    the hosted app's since 2026-10-18). A call without that ability (a test's fake) is returned unchanged."""
+    o = app_origin(origin)
+    f = getattr(call, "for_origin", None)
+    return f(o) if o and callable(f) else call
+
+
+def make_api_call(client: httpx.AsyncClient, origin: str | None = None) -> ApiCall:
+    """POST {op:'state', …} to the account API, as the Spaces app would (same Origin). `origin`: the app this account was
+    paired from (a pairing's `origin`); none → RC_ORIGIN, else the regular app."""
     api = os.environ.get("RC_BASE") or API
-    origin = os.environ.get("RC_ORIGIN") or ORIGIN
+    origin = app_origin(origin) or os.environ.get("RC_ORIGIN") or ORIGIN
 
     async def call(body: dict) -> ApiReply:
         r = await client.post(api, content=_js.stringify(body).encode("utf-8"),
@@ -45,6 +60,7 @@ def make_api_call(client: httpx.AsyncClient) -> ApiCall:
             j = None
         return ApiReply(r.status_code, j)
 
+    call.for_origin = lambda o: make_api_call(client, o)  # type: ignore[attr-defined]
     return call
 
 

{witbitz_code-1.9.3 → witbitz_code-1.9.5}/src/witbitz_code/pair.py

@@ -94,6 +94,7 @@ def ensure_local_password(out: Callable[[str], Any] = _out) -> None:
 
 
 async def _publish_entry(call: net.ApiCall, e: dict, out: Callable, err: Callable) -> bool:
+    call = net.call_for(call, e.get("origin"))  # this account's app (the hosted app's rooms refuse the regular one)
     r = await acct.publish_computer(call=call, idx=e["idx"], computer_id=e["computerId"], name=e["name"], relay=e["relay"],
                                     secret=e["secret"])
     who = e["account"] or "account"
@@ -220,7 +221,7 @@ async def _run(args: Args, call: Any, link_fn: LinkFn | None, out: Callable, err
             if entry:
                 codekeys.forget(p["computerId"])
                 _forget_payer(p["computerId"])
-            r = await acct.unpublish_computer(call=call, idx=p["idx"], computer_id=p["computerId"])
+            r = await acct.unpublish_computer(call=net.call_for(call, p.get("origin")), idx=p["idx"], computer_id=p["computerId"])
             if not r["ok"]:
                 ok = False
                 err(f"witbitz-code: ✖ {p.get('account')}: {r['why']} — kept the local pairing so you can retry")
@@ -242,7 +243,8 @@ async def _run(args: Args, call: Any, link_fn: LinkFn | None, out: Callable, err
         cur, ok = doc, True
         for p in to_rotate:
             u = pp.upsert_pairing(cur, account=p.get("account") or "", idx=p["idx"], name=p.get("name") or "",
-                                  relay=p.get("relay", UNDEFINED), opencode_url=p.get("opencodeUrl", UNDEFINED), rotate=True)
+                                  relay=p.get("relay", UNDEFINED), opencode_url=p.get("opencodeUrl", UNDEFINED),
+                                  origin=p.get("origin", UNDEFINED), rotate=True)
             if await _publish_entry(call, u["entry"], out, err):
                 cur = u["doc"]
                 pp.write_pairings(cur)
@@ -260,7 +262,7 @@ async def _run(args: Args, call: Any, link_fn: LinkFn | None, out: Callable, err
         err("witbitz-code: pairing did not complete — nothing changed.")
         return 1
     u = pp.upsert_pairing(doc, account=account.get("email") or "", idx=account["idx"], name=args.name,
-                          opencode_url=args.opencode_url or UNDEFINED)
+                          opencode_url=args.opencode_url or UNDEFINED, origin=account.get("origin") or UNDEFINED)
     # THIS COMPUTER'S CODING KEYS from the account (codekeys.py; docs/code-account-keys.md) — the only way it gets model
     # keys. Asked with the sign-in the scan carried, before anything is published: an account that cannot give keys (not
     # invited, too many computers, …) leaves nothing behind.

{witbitz_code-1.9.3 → witbitz_code-1.9.5}/src/witbitz_code/pairings.py

@@ -114,8 +114,8 @@ def norm_pairings(doc: Any) -> dict:
 
 
 def upsert_pairing(doc: Any, *, idx: dict, account: str = "", name: str = "", relay: Any = UNDEFINED,
-                   opencode_url: Any = UNDEFINED, rotate: bool = False, mint_id: Callable[[], str] = new_computer_id,
-                   mint_secret: Callable[[], str] = new_relay_secret) -> dict:
+                   opencode_url: Any = UNDEFINED, origin: Any = UNDEFINED, rotate: bool = False,
+                   mint_id: Callable[[], str] = new_computer_id, mint_secret: Callable[[], str] = new_relay_secret) -> dict:
     """Add this computer for an account, or refresh the existing entry (same id + secret unless `rotate`). Pure.
     → {doc, entry, isNew, sharedWith}: sharedWith names the other accounts that reach the same OpenCode."""
     relay = RELAY_URL if relay is UNDEFINED else relay
@@ -138,6 +138,11 @@ def upsert_pairing(doc: Any, *, idx: dict, account: str = "", name: str = "", re
         # An OpenCode asked for (`pair --port 4097`) wins; not asked → the entry keeps the one it had (tools/opencode-pair.mjs).
         "opencodeUrl": pick(None if opencode_url is UNDEFINED else opencode_url, "opencodeUrl", DEFAULT_OPENCODE_URL),
     }
+    # The app this account pairs through (its rooms answer only their own app — net.call_for). Absent = the regular app, so an
+    # entry written before 2026-10-22 (or by an older tool) reads as before, byte for byte.
+    app = pick(None if origin is UNDEFINED else origin, "origin", "")
+    if truthy(app):
+        entry["origin"] = app
     pairings = list(cur["pairings"])
     if i >= 0:
         pairings[i] = entry

{witbitz_code-1.9.3 → witbitz_code-1.9.5}/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.3 → witbitz_code-1.9.5}/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.3 → witbitz_code-1.9.5}/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.3 → witbitz_code-1.9.5/src/witbitz_code.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: witbitz-code
-Version: 1.9.3
+Version: 1.9.5
 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.3 → witbitz_code-1.9.5}/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.3 → witbitz_code-1.9.5}/tests/test_devicelink.py

@@ -220,3 +220,25 @@ def test_qr_ansi_and_svg_output_are_byte_identical_to_rc_qr():
     assert qr.render_ansi(out["rows"], compact=False) == out["large"], "and WITBITZ_QR=large"
     assert qr.render_svg(out["rows"]) == out["svg"]
     assert len(qr.qr_modules(text)) == len(out["rows"]), "and the same version: the smallest that fits at level M"
+
+
+def test_link_node_names_the_app_whose_relay_answered(tmp_path):
+    """Each origin's /api/link is polled; the account remembers which answered — the app that scanned (owner, 2026-10-22)."""
+    master = bytes([9] * 32)
+    ch = devicelink.new_link_challenge()
+    out = run_node("""
+      import { sealToChallenge, linkPayload } from '@PUBLIC@/deviceLink.js'
+      OUT({ reply: await sealToChallenge({ ref: INPUT.ref, pub: INPUT.pub },
+        linkPayload({ vault: { master: INPUT.masterB64 }, email: 'me@x', idx: { room: 'sp-idx-9', mk: 'idxmk9' } })) })
+    """, {"masterB64": _js.btoa(master), "ref": ch.ref, "pub": ch.pub})
+
+    async def get_json(url):
+        return {"ok": True, **out["reply"]} if url.startswith("https://b.test/") else {"ok": False}
+
+    async def nopost(url, body):
+        return {}
+
+    account = asyncio.run(link.link_node(life_ms=5000, poll_s=0.01, origins=["https://a.test", "https://b.test"],
+                                         get_json=get_json, post_json=nopost, challenge=ch, svg_path=tmp_path / "q.svg",
+                                         out=lambda *a, **k: None, err=lambda *a: None))
+    assert account and account["origin"] == "https://b.test"

{witbitz_code-1.9.3 → witbitz_code-1.9.5}/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,66 @@ 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"
+
+
+def test_a_pairing_from_the_hosted_app_writes_that_app_s_account_and_remembers_it():
+    """The owner, 2026-10-22: a second account added from the vaulted app failed "computers read refused (404)" — its
+    rooms answer only to the hosted app's origin. The relay that answered the scan names the app; each pairing keeps it."""
+    regular, hosted = MockApi(), MockApi()
+    asked = []
+
+    def for_origin(o):
+        asked.append(o)
+        return hosted.call
+
+    async def call(body):
+        return await regular.call(body)
+    call.for_origin = for_origin
+    keys = FakeKeys()
+
+    async def link_fn():
+        return {"email": "me@x", "idx": IDX, "master": "M" * 43, "anchor": ANCHOR, "origin": "https://spaces.witbitz.chat"}
+
+    cap = Capture()
+    assert run(pair.main(["--name", "desk"], call=call, link_fn=link_fn, keys=keys, **cap.kw())) == 0, cap.text()
+    assert asked and set(asked) == {"https://spaces.witbitz.chat"}
+    assert regular.writes == [] and hosted.writes, "the account was written through the hosted app's origin only"
+    p = pp.read_pairings()["pairings"][0]
+    assert p["origin"] == "https://spaces.witbitz.chat"
+
+    async def link_fn2():
+        return {"email": "work@y", "idx": IDX2, "master": "M" * 43, "anchor": {**ANCHOR, "email": "work@y"},
+                "origin": "https://witbitz-spaces.pages.dev"}
+
+    asked.clear()
+    assert run(pair.main([], call=call, link_fn=link_fn2, keys=keys, **Capture().kw())) == 0
+    assert set(asked) == {"https://witbitz-spaces.pages.dev"}, "a regular-app pairing writes through its own origin"
+    q = next(x for x in pp.read_pairings()["pairings"] if x["account"] == "work@y")
+    assert q["origin"] == "https://witbitz-spaces.pages.dev"
+
+    asked.clear()
+    assert run(pair.main(["--rotate", "--account", "me@x"], call=call, **Capture().kw())) == 0
+    assert set(asked) == {"https://spaces.witbitz.chat"}, "a rotate re-publishes to the app it was paired from"
+    assert next(x for x in pp.read_pairings()["pairings"] if x["account"] == "me@x")["origin"] == "https://spaces.witbitz.chat"
+
+    n = len(hosted.writes)
+    assert run(pair.main(["--unpair", "--account", "me@x"], call=call, keys=keys, **Capture().kw())) == 0
+    assert len(hosted.writes) > n, "the unpair tombstone goes to the hosted app's account too"
+
+
+def test_call_for_ignores_anything_that_is_not_an_https_origin():
+    from witbitz_code import net
+
+    async def call(body):
+        return None
+    call.for_origin = lambda o: ("other", o)
+    assert net.call_for(call, None) is call
+    assert net.call_for(call, "http://spaces.witbitz.chat") is call
+    assert net.call_for(call, "https://evil.test/path") is call
+    assert net.call_for(call, "https://spaces.witbitz.chat") == ("other", "https://spaces.witbitz.chat")
+    assert net.call_for(lambda b: None, "https://spaces.witbitz.chat") is not None

{witbitz_code-1.9.3 → witbitz_code-1.9.5}/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.3 → witbitz_code-1.9.5}/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.3 → witbitz_code-1.9.5}/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.3 → witbitz_code-1.9.5}/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))]))