witbitz-code 1.3.7__tar.gz → 1.3.8__tar.gz

{witbitz_code-1.3.7/src/witbitz_code.egg-info → witbitz_code-1.3.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: witbitz-code
-Version: 1.3.7
+Version: 1.3.8
 Summary: Reach OpenCode on this computer from the Witbitz Spaces Code section, through an end-to-end sealed relay.
 Author: Witbitz
 License-Expression: MIT
@@ -88,6 +88,10 @@ The same thing one step at a time: install OpenCode (`curl -fsSL https://opencod
 
 `pair`, `rotate` and `unpair` also accept `--dry-run`.
 
+**Windows and WSL on one computer** are two computers to Spaces, and both can run: WSL shares Windows' ports, so the second
+one `setup` meets gets its own (it asks — 4097, and 4197 for its model proxy) and `serve` remembers it. WSL's is named
+"<computer> (WSL)"; one paired before 1.3.8 is renamed by its next `setup`.
+
 **More than one account.** Each account that scans the QR code gets its own pairing, with its own secret and relay
 channel. OpenCode has no users, so every paired account reaches the same sessions, files and shell. That's fine when
 all the accounts are yours. If a second account belongs to **another person**, run a separate OpenCode for them

{witbitz_code-1.3.7 → witbitz_code-1.3.8}/README.md

@@ -62,6 +62,10 @@ The same thing one step at a time: install OpenCode (`curl -fsSL https://opencod
 
 `pair`, `rotate` and `unpair` also accept `--dry-run`.
 
+**Windows and WSL on one computer** are two computers to Spaces, and both can run: WSL shares Windows' ports, so the second
+one `setup` meets gets its own (it asks — 4097, and 4197 for its model proxy) and `serve` remembers it. WSL's is named
+"<computer> (WSL)"; one paired before 1.3.8 is renamed by its next `setup`.
+
 **More than one account.** Each account that scans the QR code gets its own pairing, with its own secret and relay
 channel. OpenCode has no users, so every paired account reaches the same sessions, files and shell. That's fine when
 all the accounts are yours. If a second account belongs to **another person**, run a separate OpenCode for them

{witbitz_code-1.3.7 → witbitz_code-1.3.8}/pyproject.toml

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

{witbitz_code-1.3.7 → witbitz_code-1.3.8}/src/witbitz_code/cli.py

@@ -156,6 +156,10 @@ async def serve(args: list[str]) -> int:
     if not everything:
         _err("witbitz-code: this computer is not paired yet — run: witbitz-code setup")
         return 1
+    # No --port: the port this computer is paired for (setup moves a pairing off a port WSL's or Windows' copy holds)
+    paired_ports = sorted({wizard.port_of(p) for p in everything})
+    if "--port" not in args and len(paired_ports) == 1:
+        port = paired_ports[0]
     # One OpenCode per port, one connector per OpenCode: two `serve`s (one per account) must never both answer a channel.
     pairings = pairings_for_port(everything, port)
     if not pairings:
@@ -311,7 +315,7 @@ async def setup(args: list[str]) -> int:
     d = wizard.Deps(
         say=_err, ask=lambda q: keys.read_line(q), secret=lambda q: keys.read_line(q, hidden=True),
         port=port, port_explicit="--port" in args,
-        pair=lambda p: pair_cmd.main(["--port", str(p)]),
+        pair=lambda p: pair_cmd.main(["--port", str(p)]), rename=lambda p, name: pair_cmd.rename(p, name),
         keys_state=keys_state,
         run_tools=lambda plan: toolsetup.run_plan(plan, say=_err), refresh_path=refresh_path,
         is_listening=is_listening, serve_here=lambda p: serve(["--port", str(p)]),

{witbitz_code-1.3.7 → witbitz_code-1.3.8}/src/witbitz_code/pair.py

@@ -124,6 +124,26 @@ async def _link_by_qr(link_fn: LinkFn | None, out: Callable, err: Callable) -> d
     return account
 
 
+async def rename(pairing: dict, name: str, *, call: net.ApiCall | None = None, out: Callable[[str], Any] = _out,
+                 err: Callable[[str], Any] = _err) -> bool:
+    """A pairing's label: in the account's computers (devices show it at their next sync), then in the pairings file. No scan."""
+    client = None
+    if call is None:
+        client = net.new_client()
+        call = net.make_api_call(client)
+    try:
+        if not await _publish_entry(call, {**pairing, "name": name}, out, err):
+            return False
+    finally:
+        if client is not None:
+            await client.aclose()
+    doc = pp.read_pairings()
+    doc["pairings"] = [({**x, "name": name} if isinstance(x, dict) and x.get("computerId") == pairing.get("computerId") else x)
+                       for x in doc.get("pairings") or []]
+    pp.write_pairings(doc)
+    return True
+
+
 async def main(argv: list[str], *, call: net.ApiCall | None = None, link_fn: LinkFn | None = None,
                out: Callable[[str], Any] = _out, err: Callable[[str], Any] = _err, keys: Any = None) -> int:
     """pair / --status / --unpair / --rotate. Returns the exit code. `keys`: the coding-key calls (codekeys.mint /

{witbitz_code-1.3.7 → witbitz_code-1.3.8}/src/witbitz_code/pairings.py

@@ -91,7 +91,13 @@ def new_computer_id() -> str:
 
 
 def hostname() -> str:
-    return socket.gethostname()
+    """The label a new pairing gets: this computer's name — on WSL "<name> (WSL)": WSL calls itself by the Windows computer's
+    name, and the Windows side and the Linux side are two computers in the account (the owner, 2026-10-09: "one running in
+    WSL and one in windows … noted as separate devices")."""
+    from .ports import on_wsl  # noqa: PLC0415
+
+    h = socket.gethostname()
+    return f"{h} (WSL)" if on_wsl() else h
 
 
 # ── the pairings doc (pure) ───────────────────────────────────────────────────────────────────────────────────────────

{witbitz_code-1.3.7 → witbitz_code-1.3.8}/src/witbitz_code/ports.py

@@ -137,3 +137,31 @@ def win_owners(port: int, *, run: Callable[[list[str]], str] = _run_text, user:
         if row and row["pid"] == pid and (not user or row["user"].rsplit("\\", 1)[-1].lower() == user.lower()):
             hits.append({"pid": pid, "cmd": row["image"]})
     return hits
+
+
+def _run_status(argv: list[str], env: dict | None = None) -> tuple[int, str]:
+    try:
+        r = subprocess.run(argv, capture_output=True, text=True, errors="replace", timeout=15, env=env)
+        return r.returncode, r.stdout or ""
+    except (OSError, subprocess.SubprocessError):
+        return -1, ""
+
+
+def wsl_running(run: Callable[[list[str]], tuple[int, str]] | None = None) -> list[str]:
+    """Windows: the WSL distros running now. WSL_UTF8=1, or wsl.exe answers in UTF-16; a distro name has no spaces, so a
+    message line ("There are no running distributions.") is never taken for one."""
+    run = run or (lambda argv: _run_status(argv, {**os.environ, "WSL_UTF8": "1"}))
+    code, out = run(["wsl", "-l", "--running", "-q"])
+    if code != 0:
+        return []
+    return [n for n in (ln.strip() for ln in out.replace("\x00", "").splitlines()) if re.fullmatch(r"[A-Za-z0-9._-]+", n)]
+
+
+def held_in_wsl(port: int, *, platform: str | None = None, run: Callable[[list[str]], str] = _run_text,
+                wsl: Callable[[], list[str]] = wsl_running) -> list[str]:
+    """Windows: the running WSL distros, when `port` answers but no Windows program listens on it — Linux and Windows share
+    localhost ports (WSL's mirrored networking) and Windows cannot name the Linux program (the owner's laptop, 2026-10-09:
+    netstat showed nothing on 4096, UbuntuD was running an earlier witbitz-code serve). [] off Windows."""
+    if (sys.platform if platform is None else platform) != "win32" or parse_netstat_listeners(run(["netstat", "-ano"]), port):
+        return []
+    return wsl()

{witbitz_code-1.3.7 → witbitz_code-1.3.8}/src/witbitz_code/toolsetup.py

@@ -119,6 +119,15 @@ def install_release(step: dict, *, client: httpx.Client | None = None, dest: str
     return str(to)
 
 
+# winget's "no newer version" (APPINSTALLER_CLI_ERROR_UPDATE_NOT_APPLICABLE, 0x8A15002B) and "already installed"
+# (0x8A150061): the tool is HERE (the owner's laptop, 2026-10-09: Pandoc and ImageMagick "ended with 2316632107"). = runPlan
+WINGET_ALREADY = (0x8A15002B, 0x8A150061)
+
+
+def already_installed(argv: list[str], code: int) -> bool:
+    return argv[:1] == ["winget"] and code != -1 and (code & 0xFFFFFFFF) in WINGET_ALREADY
+
+
 def run_plan(steps: list[dict], *, say: Callable[[str], Any] = print, run: Callable[[list[str]], int] = run_inherit,
              release: Callable[[dict], str] = install_release) -> dict:
     """Carry out the plan → {done, failed, auto, none} (tool ids). Says each step as it goes. = code-tools-install.mjs runPlan"""
@@ -127,8 +136,11 @@ def run_plan(steps: list[dict], *, say: Callable[[str], Any] = print, run: Calla
         if s["kind"] == "cmd":
             say(f"   $ {s['argv'][2] if s['argv'][0] == 'sh' else ' '.join(s['argv'])}")
             code = run(s["argv"])
-            (out["done"] if code == 0 else out["failed"]).extend(s["ids"])
-            if code != 0:
+            here = code != 0 and already_installed(s["argv"], code)
+            (out["done"] if code == 0 or here else out["failed"]).extend(s["ids"])
+            if here:
+                say(f"   ✓ {', '.join(label(i) for i in s['ids'])}: already installed")
+            elif code != 0:
                 say(f"   ✖ {', '.join(label(i) for i in s['ids'])}: that {'could not start' if code == -1 else f'ended with {code}'}")
         elif s["kind"] == "release":
             say(f"   Downloading {label(s['id'])} ({s['mb']} MB) from its publisher, checked against its SHA-256 …")

{witbitz_code-1.3.7 → witbitz_code-1.3.8}/src/witbitz_code/wizard.py

@@ -14,6 +14,7 @@ from __future__ import annotations
 import asyncio
 import os
 import shutil
+import socket
 import subprocess
 import sys
 from collections.abc import Awaitable, Callable
@@ -75,6 +76,9 @@ class Deps:
     forget_keys: Callable[[dict], Any] = lambda p: codekeys.forget(p.get("computerId") or "")
     is_listening: Callable[[int], Awaitable[bool]] = None  # type: ignore[assignment]
     port_owners: Callable[[int], list] = ports.port_owners  # [{pid, cmd}] — this user's processes on a port (ports.py)
+    held_in_wsl: Callable[[int], list] = ports.held_in_wsl  # Windows: running WSL distros when no Windows program holds the port
+    bare_host: Callable[[], str] = socket.gethostname  # the computer's own name (WSL reports Windows')
+    rename: Callable[[dict, str], Awaitable[bool]] | None = None  # pair.rename: a pairing's label, here and in the account
     stop_process: Callable[[int], bool] = lambda pid: __import__("witbitz_code.uninstall", fromlist=["stop_process"]).stop_process(pid)
     wsl: bool = field(default_factory=ports.on_wsl)
     # setup's Tools step (toolsetup.py): what is here, carrying out the plan, and PATH after installs (Windows: the registry)
@@ -158,6 +162,11 @@ async def run_setup(d: Deps) -> dict:
             d.say(f"   ✖ This computer is paired, but for OpenCode on another port. Run setup again with that port: witbitz-code setup --port {d.port_of(everything[0])}"
                   if everything else "   ✖ Pairing did not finish. Run setup again to retry.")
             return {**result, "stopped": "pair"}
+    if d.wsl and d.rename:  # WSL calls itself by the Windows computer's name: two computers in the account, one name (1.3.7 and before)
+        for p in [x for x in mine if x.get("name") == d.bare_host()]:
+            if await d.rename(p, f"{p['name']} (WSL)"):
+                d.say(f'   ✓ Renamed this computer "{p["name"]} (WSL)" — Windows on the same machine keeps "{p["name"]}"')
+        mine = on(d.all_pairings(), port)
     d.say(f"   ✓ Paired: {named(mine)}{f' (OpenCode on port {port})' if port != 4096 else ''}")
     result["paired"] = True
 
@@ -201,9 +210,24 @@ async def run_setup(d: Deps) -> dict:
                 if all(o["pid"] != x["pid"] for x in owners):
                     owners.append(o)
         if not owners:
-            d.say(f"   Port {busy[0]} is taken by a program that is not yours{' — on WSL, another Linux distro on this computer shares its ports' if d.wsl else ''}.")
-            d.say(f"   Run setup with another port: witbitz-code setup --port {port + 1}")
-            return {**result, "stopped": "busy"}
+            # Not this person's program here — on Windows most likely the witbitz-code in WSL (Linux and Windows share these
+            # ports; the owner, 2026-10-09: "I want one running in WSL and one in windows"). Both can run: this one moves.
+            free = await _free_port(d, port + 1)
+            distros = d.held_in_wsl(busy[0])
+            if distros:
+                d.say(f"   Port {busy[0]} is used inside WSL (Linux on this computer — running: {', '.join(distros)}), most likely by the")
+                d.say("   witbitz-code there: Windows and WSL share these ports. Both can run — this one just needs its own.")
+            else:
+                d.say(f"   Port {busy[0]} is taken by a program that is not yours{' — on WSL, Windows and the other Linux distros on this computer share its ports' if d.wsl else ''}.")
+            if not _yes(d.ask(f"   Use port {free} (and {free + 100} for the model proxy) here instead? [Y/n] ")):
+                d.say(f"   Stopped. To use another port later: witbitz-code setup --port {free}"
+                      + ("  — or stop WSL's copy: wsl --shutdown" if distros else ""))
+                return {**result, "stopped": "busy"}
+            for p in on(d.all_pairings(), port):
+                d.move_pairing(p, free)
+            d.say(f"   ✓ This computer now uses port {free} — `witbitz-code serve` remembers it")
+            port = free
+            continue
         listed = "; ".join(f"{(o.get('cmd') or 'a program')[:70]} (process {o['pid']})" for o in owners)
         d.say(f"   Already running here: {listed}.")
         d.say("   That is an earlier witbitz-code or an OpenCode started some other way — it would keep answering your phone with")
@@ -240,8 +264,20 @@ def _describe(step: dict) -> str:
     return f"     {toolsetup.label(step['id'])}: nothing here installs it" + (f" ({step['note']})" if step.get("note") else "")
 
 
+async def _free_port(d: Deps, start: int) -> int:
+    """The first port from `start` that is free together with its model proxy's (port + 100)."""
+    for p in range(max(start, 1024), 65436):
+        if not await d.is_listening(p) and not await d.is_listening(p + 100):
+            return p
+    return start
+
+
 async def _tools_step(d: Deps) -> str:
     """→ 'here' | 'installed' | 'partly' | 'skipped' | 'unavailable' | 'failed' (an install that breaks never ends setup)."""
+    try:  # Windows: what an earlier setup installed is on the registry's PATH, not yet on this window's — read it FIRST, or
+        d.refresh_path()  # winget is asked again for tools that are here (the owner's laptop, 2026-10-09: Pandoc, ImageMagick)
+    except Exception:  # noqa: BLE001
+        pass
     try:
         report = d.probe_tools()
     except Exception:  # noqa: BLE001 — a probe that fails never stops setup

{witbitz_code-1.3.7 → witbitz_code-1.3.8/src/witbitz_code.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: witbitz-code
-Version: 1.3.7
+Version: 1.3.8
 Summary: Reach OpenCode on this computer from the Witbitz Spaces Code section, through an end-to-end sealed relay.
 Author: Witbitz
 License-Expression: MIT
@@ -88,6 +88,10 @@ The same thing one step at a time: install OpenCode (`curl -fsSL https://opencod
 
 `pair`, `rotate` and `unpair` also accept `--dry-run`.
 
+**Windows and WSL on one computer** are two computers to Spaces, and both can run: WSL shares Windows' ports, so the second
+one `setup` meets gets its own (it asks — 4097, and 4197 for its model proxy) and `serve` remembers it. WSL's is named
+"<computer> (WSL)"; one paired before 1.3.8 is renamed by its next `setup`.
+
 **More than one account.** Each account that scans the QR code gets its own pairing, with its own secret and relay
 channel. OpenCode has no users, so every paired account reaches the same sessions, files and shell. That's fine when
 all the accounts are yours. If a second account belongs to **another person**, run a separate OpenCode for them

{witbitz_code-1.3.7 → witbitz_code-1.3.8}/tests/test_pair_flows.py

@@ -274,3 +274,30 @@ def test_status_output_is_json_free_of_secrets_even_for_js_written_files():
     run(pair.main(["--status"], **cap.kw()))
     assert SECRET not in cap.text() and "MK" not in cap.text()
     assert json.loads(pp.pairings_path().read_text())["pairings"][0]["secret"] == SECRET
+
+
+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,
+             "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
+    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)"]
+    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"
+
+
+def test_a_new_pairing_on_wsl_is_named_for_wsl(monkeypatch):
+    import socket
+
+    from witbitz_code import ports
+
+    monkeypatch.setattr(socket, "gethostname", lambda: "AlonASUS")
+    monkeypatch.setattr(ports, "on_wsl", lambda: True)
+    assert pp.hostname() == "AlonASUS (WSL)"
+    monkeypatch.setattr(ports, "on_wsl", lambda: False)
+    assert pp.hostname() == "AlonASUS"

{witbitz_code-1.3.7 → witbitz_code-1.3.8}/tests/test_ports_win.py

@@ -81,3 +81,29 @@ def test_stopping_on_windows_is_taskkill_of_the_tree_and_never_os_kill(monkeypat
     monkeypatch.setattr(sys, "platform", "win32")
     monkeypatch.setattr(uninstall, "win_stop_process", lambda pid: stopped.append(pid) or True)
     assert uninstall.stop_process(5150) is True and stopped == [5150]
+
+
+def test_wsl_is_named_only_when_no_windows_program_holds_the_port():
+    wsl = lambda: ["UbuntuD"]  # noqa: E731
+    assert ports.held_in_wsl(4096, platform="win32", run=lambda a: NETSTAT, wsl=wsl) == [], "opencode.exe holds 4096 here"
+    assert ports.held_in_wsl(4097, platform="win32", run=lambda a: NETSTAT, wsl=wsl) == ["UbuntuD"]
+    assert ports.held_in_wsl(4097, platform="linux", run=lambda a: NETSTAT, wsl=wsl) == []
+
+
+def test_running_distros_are_read_whatever_wsl_prints():
+    assert ports.wsl_running(lambda a: (0, "UbuntuD\r\nDebian\r\n")) == ["UbuntuD", "Debian"]
+    assert ports.wsl_running(lambda a: (0, "U\x00b\x00u\x00n\x00t\x00u\x00D\x00\r\x00\n\x00")) == ["UbuntuD"], "UTF-16 read as text"
+    assert ports.wsl_running(lambda a: (0, "There are no running distributions.\r\n")) == []
+    assert ports.wsl_running(lambda a: (1, "UbuntuD")) == [], "an error answer names nothing"
+
+
+@requires_node
+def test_the_javascript_names_wsl_the_same_way():
+    js = run_node("""
+      import { heldInWsl, wslRunning } from '@TOOLS@/code-ports-win.mjs'
+      OUT({ held: [4096, 4097].map((p) => heldInWsl(p, { platform: 'win32', run: () => INPUT.netstat, wsl: () => ['UbuntuD'] })),
+            off: heldInWsl(4097, { platform: 'linux', run: () => INPUT.netstat, wsl: () => ['UbuntuD'] }),
+            names: INPUT.outs.map(([status, out]) => wslRunning({ run: () => ({ status, out }) })) })
+    """, {"netstat": NETSTAT, "outs": [[0, "UbuntuD\r\nDebian\r\n"], [0, "U\x00b\x00u\x00n\x00t\x00u\x00D\x00\r\x00\n\x00"], [0, "There are no running distributions.\r\n"], [1, "UbuntuD"]]})
+    assert js["held"] == [[], ["UbuntuD"]] and js["off"] == []
+    assert js["names"] == [["UbuntuD", "Debian"], ["UbuntuD"], [], []]

{witbitz_code-1.3.7 → witbitz_code-1.3.8}/tests/test_setup.py

@@ -101,6 +101,9 @@ class Fake:
         self._oc, self._pairings, self._keyed, self._gives = opencode, list(pairings or []), set(keyed), pair_gives_keys
         self._answers, self._listening = list(answers), listening
 
+    def _move(self, p, port):
+        self._pairings = [({**x, "opencodeUrl": f"http://127.0.0.1:{port}"} if x.get("computerId") == p.get("computerId") else x) for x in self._pairings]
+
     def deps(self, **over):
         async def pair(port):
             self.paired.append(port)
@@ -109,19 +112,19 @@ class Fake:
             if self._gives:
                 self._keyed.add("c")
         async def listening(port):
-            return self._listening
+            return self._listening(port) if callable(self._listening) else self._listening
         async def serve_here(port):
             self.served.append(port)
             return 0
         return wizard.Deps(
             say=self.said.append, ask=lambda q: self._answers.pop(0) if self._answers else "", secret=lambda q: self.asked_secret.append(q) or "",
             find_opencode=lambda: "/usr/bin/opencode" if self._oc else "", can_install_opencode=lambda: False,
-            all_pairings=lambda: list(self._pairings), pair=pair, move_pairing=lambda p, port: None,
+            all_pairings=lambda: list(self._pairings), pair=pair, move_pairing=self._move,
             code_keys=lambda p: {"caps": {"modelsUsd": 50, "toolsUsd": 5}} if p.get("computerId") in self._keyed else None,
             serve_here=serve_here,
             # never this machine's real processes: the real lookup finds whatever listens on 4096 HERE (an OpenCode does)
             # and never this machine's tools: nothing is missing, nothing is installed (the Tools step has its own tests)
-            **{"is_listening": listening, "port_owners": lambda port: [], "stop_process": lambda pid: False, "wsl": False,
+            **{"is_listening": listening, "port_owners": lambda port: [], "held_in_wsl": lambda port: [], "stop_process": lambda pid: False, "wsl": False,
                "probe_tools": lambda: {"tools": {}, "platform": {"os": "", "pm": ""}}, "run_tools": lambda plan: {}, "refresh_path": lambda: None, **over})
 
 
@@ -166,12 +169,19 @@ def test_paired_for_another_port_uses_it():
     assert r["port"] == 4097 and f.served == [4097] and f.paired == []
 
 
-def test_a_port_taken_by_a_program_that_is_not_yours_stops_setup_with_another_port_to_use():
-    f = Fake(listening=True)
+DESK = {"name": "desk", "opencodeUrl": "http://127.0.0.1:4096", "idx": {"room": "r"}, "computerId": "c"}
+HELD = lambda p: p in (4096, 4196)  # noqa: E731 — OpenCode's port and the proxy's, held by someone else
+
+
+def test_a_port_taken_by_a_program_that_is_not_yours_moves_this_computer_to_a_free_pair_and_serves():
+    f = Fake(pairings=[DESK], keyed={"c"}, listening=HELD, answers=[""])
     r = run(wizard.run_setup(f.deps()))
-    assert r["stopped"] == "busy" and f.served == []
+    assert f.served == [4097] and wizard.port_of(f._pairings[0]) == 4097, "the pairing moves — no new scan"
     assert any("Port 4096 is taken by a program that is not yours" in line for line in f.said)
-    assert any("witbitz-code setup --port 4097" in line for line in f.said)
+    assert any("now uses port 4097" in line for line in f.said) and "stopped" not in r
+    no = Fake(pairings=[DESK], keyed={"c"}, listening=HELD, answers=["n"])
+    assert run(wizard.run_setup(no.deps()))["stopped"] == "busy" and no.served == []
+    assert any("witbitz-code setup --port 4097" in line for line in no.said)
 
 
 def test_an_earlier_witbitz_code_still_running_is_named_and_stopped_both_ports_then_this_one_serves():
@@ -222,3 +232,37 @@ def test_keys_that_cannot_be_checked_are_not_taken_for_a_removal_and_setup_says_
     r = run(wizard.run_setup(f.deps(keys_state=keys_state, forget_keys=lambda p: f._keyed.discard(p["computerId"]))))
     assert f.paired == [] and r["keys"] and f.served == [4096]
     assert any("Could not check them with your account just now — the signature does not match this computer (401)" in line for line in f.said)
+
+
+def test_windows_and_wsl_each_run_their_own_the_windows_one_moves_off_the_port_wsl_holds():
+    # the owner's laptop, 2026-10-09: 4096 answered, netstat showed no Windows program, UbuntuD ran witbitz-code serve —
+    # "I want one running in WSL and one in windows"
+    f = Fake(pairings=[DESK], keyed={"c"}, listening=HELD, answers=[""])
+    run(wizard.run_setup(f.deps(held_in_wsl=lambda port: ["UbuntuD"])))
+    assert f.served == [4097]
+    assert any("Port 4096 is used inside WSL (Linux on this computer — running: UbuntuD)" in line for line in f.said)
+    assert not any("not yours" in line for line in f.said)
+    no = Fake(pairings=[DESK], keyed={"c"}, listening=HELD, answers=["n"])
+    assert run(wizard.run_setup(no.deps(held_in_wsl=lambda port: ["UbuntuD"])))["stopped"] == "busy"
+    assert any("wsl --shutdown" in line for line in no.said)
+
+
+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
+    f = Fake(pairings=[DESK], keyed={"c"})
+    renamed = []
+
+    async def rename(p, name):
+        renamed.append((p["computerId"], name))
+        f._pairings = [{**x, "name": name} for x in f._pairings]
+        return True
+
+    run(wizard.run_setup(f.deps(wsl=True, bare_host=lambda: "desk", rename=rename)))
+    assert renamed == [("c", "desk (WSL)")] and any('Renamed this computer "desk (WSL)"' in line for line in f.said)
+    assert any('✓ Paired: "desk (WSL)"' in line for line in f.said)
+    again = Fake(pairings=[{**DESK, "name": "desk (WSL)"}], keyed={"c"})
+    run(wizard.run_setup(again.deps(wsl=True, bare_host=lambda: "desk", rename=rename)))
+    assert len(renamed) == 1, "a renamed one is left alone"
+    off = Fake(pairings=[DESK], keyed={"c"})
+    run(wizard.run_setup(off.deps(wsl=False, bare_host=lambda: "desk", rename=rename)))
+    assert len(renamed) == 1, "Windows keeps the computer's own name"

{witbitz_code-1.3.7 → witbitz_code-1.3.8}/tests/test_toolsetup.py

@@ -127,7 +127,7 @@ def step(tools: Tools, answers: list[str]) -> tuple[str, list[str]]:
 def test_setup_asks_once_installs_mechanically_and_checks_again():
     t = Tools(["ffmpeg", "poppler", "tesseract", "whisper"], {"os": "win32", "pm": "winget"})
     r, said = step(t, [""])
-    assert r == "installed" and t.refreshed == 1
+    assert r == "installed" and t.refreshed == 2, "once before the first look, once after the installs"
     assert [s["kind"] for s in t.plans[0]] == ["cmd", "release", "cmd"], "Whisper is not asked for on Windows: it comes by itself"
     assert any("Missing here: ffmpeg, Poppler, Tesseract." in s for s in said) and any("42 MB download" in s for s in said)
 
@@ -203,3 +203,24 @@ def test_no_module_uses_a_name_it_never_defined():
     for f in sorted(Path(witbitz_code.__file__).parent.glob("*.py")):
         pyflakes.api.check(f.read_text(encoding="utf-8"), str(f), rep)
     assert rep.found == []
+
+
+def test_tools_an_earlier_setup_installed_are_seen_before_anything_is_asked():
+    # the owner's laptop, 2026-10-09: this window's PATH predated the installs, so Pandoc and ImageMagick were "missing"
+    # and winget was asked again; the registry's PATH (refresh_path) had them all along
+    t = Tools(["pandoc", "imagemagick", "jq"], {"os": "win32", "pm": "winget"})
+    said: list[str] = []
+    d = wizard.Deps(say=said.append, ask=lambda q: "", secret=lambda q: "", probe_tools=t.probe, run_tools=t.run,
+                    refresh_path=lambda: t.missing.difference_update({"pandoc", "imagemagick"}))
+    assert asyncio.run(wizard._tools_step(d)) == "installed"
+    assert [i for st in t.plans[0] for i in (st.get("ids") or [st.get("id")])] == ["jq"]
+
+
+def test_wingets_already_installed_is_done_not_a_failure():
+    said: list[str] = []
+    codes = {"Pandoc": 2316632107, "ImageMagick": -1978335189, "qpdf": 1}  # 0x8A15002B unsigned, then signed; a real failure
+    steps = [{"kind": "cmd", "ids": [i], "argv": ["winget", "install", "--id", n]} for i, n in (("pandoc", "Pandoc"), ("imagemagick", "ImageMagick"), ("qpdf", "qpdf"))]
+    out = ts.run_plan(steps, say=said.append, run=lambda argv: codes[argv[-1]])
+    assert out["done"] == ["pandoc", "imagemagick"] and out["failed"] == ["qpdf"]
+    assert "   ✓ Pandoc: already installed" in said and "   ✓ ImageMagick: already installed" in said
+    assert ts.run_plan([{"kind": "cmd", "ids": ["jq"], "argv": ["brew", "install", "jq"]}], say=said.append, run=lambda a: 2316632107)["failed"] == ["jq"], "only winget's code means that"