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

{witbitz_code-1.3.6/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.6
+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.6 → 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.6 → witbitz_code-1.3.8}/pyproject.toml

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

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

@@ -156,11 +156,20 @@ 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:
         _err(f"witbitz-code: no pairing uses OpenCode on port {port} — pair with: witbitz-code pair --port {port}")
         return 1
+    # Windows: a tool installed since this window opened (setup's Tools step, winget) is on the registry's PATH, not yet on
+    # this process's — read it, so the agent's OpenCode finds it (= witbitz-code.mjs serve)
+    reg = toolsetup.registry_path()
+    if reg:
+        os.environ["PATH"] = toolsetup.merged_path(os.environ.get("PATH", ""), reg)
     # Our OpenCode plugins — project notes, and the agent's progress updates the Code section shows between its work rows —
     # written into OpenCode's config folder on every start (plugins.py). OpenCode reads them when it starts, so one already
     # running picks them up at its next restart.
@@ -306,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.6 → 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.6 → 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.8/src/witbitz_code/ports.py

@@ -0,0 +1,167 @@
+"""Who is listening on a port of this computer — this user's processes only (= tools/witbitz-code.mjs portOwners).
+
+setup asks it before starting: an earlier witbitz-code still running (`pipx uninstall` does not stop it) holds OpenCode's
+port and the model proxy's (port + 100), and keeps answering the phone with the keys it started with (the owner,
+2026-10-08: "could not start the model proxy … address already in use", then "Invalid API key"). Linux reads /proc; macOS
+asks lsof; Windows asks netstat and tasklist (_win_owners, = tools/code-ports-win.mjs — before 1.3.7 Windows knew nobody and
+setup called the person's own `witbitz-code serve` "a program that is not yours"); elsewhere nothing is known.
+"""
+
+from __future__ import annotations
+
+import os
+import shutil
+import re
+import subprocess
+import sys
+from collections.abc import Callable
+from pathlib import Path
+
+
+def port_owners(port: int) -> list[dict]:
+    """[{pid, cmd}] of this user's processes listening on 127.0.0.1/::1 `port` (never this process)."""
+    if sys.platform == "win32":
+        return win_owners(port)
+    if Path("/proc/net/tcp").exists():
+        return _proc_owners(port)
+    if shutil.which("lsof"):
+        return _lsof_owners(port)
+    return []
+
+
+def _proc_owners(port: int) -> list[dict]:
+    inodes: set[str] = set()
+    for f in ("/proc/net/tcp", "/proc/net/tcp6"):
+        try:
+            lines = Path(f).read_text().splitlines()[1:]
+        except OSError:
+            continue
+        for line in lines:
+            c = line.split()
+            if len(c) >= 10 and c[3] == "0A" and int(c[1].rsplit(":", 1)[-1], 16) == port:  # 0A = LISTEN
+                inodes.add(c[9])
+    if not inodes:
+        return []
+    hits = []
+    for p in os.listdir("/proc"):
+        if not p.isdigit() or int(p) == os.getpid():
+            continue
+        try:
+            fds = os.listdir(f"/proc/{p}/fd")
+        except OSError:
+            continue  # not this user's
+        owns = False
+        for fd in fds:
+            try:
+                link = os.readlink(f"/proc/{p}/fd/{fd}")
+            except OSError:
+                continue
+            if link.startswith("socket:[") and link[8:-1] in inodes:
+                owns = True
+                break
+        if not owns:
+            continue
+        try:
+            cmd = " ".join(x for x in Path(f"/proc/{p}/cmdline").read_bytes().decode("utf-8", "replace").split("\0") if x)
+        except OSError:
+            cmd = ""
+        hits.append({"pid": int(p), "cmd": cmd})
+    return hits
+
+
+def _lsof_owners(port: int) -> list[dict]:
+    try:
+        out = subprocess.run(["lsof", "-nP", f"-iTCP:{port}", "-sTCP:LISTEN", "-t"], capture_output=True, text=True, timeout=10).stdout
+    except (OSError, subprocess.SubprocessError):
+        return []
+    hits = []
+    for pid in sorted({int(x) for x in out.split() if x.isdigit()}):
+        if pid == os.getpid():
+            continue
+        try:
+            cmd = subprocess.run(["ps", "-o", "command=", "-p", str(pid)], capture_output=True, text=True, timeout=5).stdout.strip()
+        except (OSError, subprocess.SubprocessError):
+            cmd = ""
+        hits.append({"pid": pid, "cmd": cmd})
+    return hits
+
+
+def on_wsl() -> bool:
+    try:
+        return "microsoft" in Path("/proc/version").read_text().lower()
+    except OSError:
+        return False
+
+
+def parse_netstat_listeners(text: str, port: int) -> list[int]:
+    """The process ids listening on TCP `port`, from `netstat -ano` output. A listening socket's foreign address is 0.0.0.0:0
+    or [::]:0 — the State column is translated on some Windows languages, the addresses are not."""
+    pids: set[int] = set()
+    for line in (text or "").splitlines():
+        c = line.split()
+        if len(c) < 5 or c[0].upper() != "TCP" or not c[1].endswith(f":{port}") or c[2] not in ("0.0.0.0:0", "[::]:0"):
+            continue
+        if c[-1].isdigit() and int(c[-1]) > 0:
+            pids.add(int(c[-1]))
+    return sorted(pids)
+
+
+def parse_tasklist_row(text: str) -> dict | None:
+    """One CSV row of `tasklist /V /FO CSV /NH` → {image, pid, user}, or None."""
+    line = next((ln for ln in (text or "").splitlines() if ln.strip().startswith('"')), None)
+    if line is None:
+        return None
+    cells = [m.replace('""', '"') for m in re.findall(r'"((?:[^"]|"")*)"', line)]
+    if len(cells) < 7 or not cells[1].isdigit():
+        return None
+    return {"image": cells[0], "pid": int(cells[1]), "user": cells[6]}
+
+
+def _run_text(argv: list[str]) -> str:
+    try:
+        return subprocess.run(argv, capture_output=True, text=True, errors="replace", timeout=15).stdout or ""
+    except (OSError, subprocess.SubprocessError):
+        return ""
+
+
+def win_owners(port: int, *, run: Callable[[list[str]], str] = _run_text, user: str | None = None, self_pid: int | None = None) -> list[dict]:
+    """[{pid, cmd}] of this user's processes listening on `port` on Windows: netstat for the ids, tasklist for each one's
+    program and user (another user's process says N/A and is left out)."""
+    user = os.environ.get("USERNAME", "") if user is None else user
+    self_pid = os.getpid() if self_pid is None else self_pid
+    hits = []
+    for pid in parse_netstat_listeners(run(["netstat", "-ano"]), port):
+        if pid == self_pid:
+            continue
+        row = parse_tasklist_row(run(["tasklist", "/V", "/FO", "CSV", "/NH", "/FI", f"PID eq {pid}"]))
+        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.6 → witbitz_code-1.3.8}/src/witbitz_code/tools_probe.py

@@ -30,6 +30,28 @@ _EXTRA_HOME = [".local/bin", ".cargo/bin", "bin"]
 # Windows: under %LOCALAPPDATA%\Witbitz — what the Windows installer (code.ps1) fills and witbitz-code serve gives the agent:
 # its Git (Git Bash, the agent's shell), its own Python, and what setup's Tools step puts there (Poppler). = code-tools-probe.mjs
 _WIN_WITBITZ = ["bin", "git\\cmd", "git\\bin", "agent-python\\Scripts", "poppler\\bin"]
+# Windows: tools whose installers do not add themselves to PATH (measured 2026-10-09 on the owner's laptop: winget installed
+# Tesseract (UB-Mannheim) and qpdf, setup's re-check still found neither) — their usual folders. = code-tools-probe.mjs
+_WIN_PROGRAM_ROOTS = ["ProgramFiles", "ProgramW6432", "ProgramFiles(x86)"]
+
+
+def _listdir(d: str) -> list[str]:
+    try:
+        return os.listdir(d)
+    except OSError:
+        return []
+
+
+def win_program_dirs(env: Mapping[str, str], listdir: Callable[[str], list[str]] = _listdir) -> list[str]:
+    """Tesseract-OCR and qpdf <version>\\bin under Program Files (all three) and %LOCALAPPDATA%\\Programs."""
+    roots = [(env.get(k) or "").rstrip("\\/") for k in _WIN_PROGRAM_ROOTS]
+    local = (env.get("LOCALAPPDATA") or "").rstrip("\\/")
+    roots = list(dict.fromkeys([r for r in roots + ([f"{local}\\Programs"] if local else []) if r]))
+    out: list[str] = []
+    for r in roots:
+        out.append(f"{r}\\Tesseract-OCR")
+        out += [f"{r}\\{n}\\bin" for n in sorted(listdir(r)) if n.lower().startswith("qpdf")]
+    return out
 
 
 def _is_executable(path: str) -> bool:
@@ -40,26 +62,26 @@ def _is_executable(path: str) -> bool:
     return stat.S_ISREG(st.st_mode) and os.access(path, os.X_OK)
 
 
-def search_dirs(*, env: Mapping[str, str], platform: str, home: str) -> list[str]:
+def search_dirs(*, env: Mapping[str, str], platform: str, home: str, listdir: Callable[[str], list[str]] = _listdir) -> list[str]:
     """The folders searched, in order, without repeats."""
     win = platform == "win32"
     raw = env.get("PATH") or env.get("Path") or ""
     from_path = [d for d in raw.split(";" if win else ":") if d]
     if win:
         local = (env.get("LOCALAPPDATA") or "").rstrip("\\/")
-        extra = [f"{local}\\Witbitz\\{d}" for d in _WIN_WITBITZ] if local else []
+        extra = ([f"{local}\\Witbitz\\{d}" for d in _WIN_WITBITZ] if local else []) + win_program_dirs(env, listdir)
     else:
         extra = _EXTRA_POSIX + ([f"{home.rstrip('/')}/{d}" for d in _EXTRA_HOME] if home else [])
     return list(dict.fromkeys(from_path + extra))
 
 
 def probe_tools(*, env: Mapping[str, str] | None = None, platform: str | None = None, home: str | None = None,
-                is_executable: Callable[[str], bool] = _is_executable) -> dict:
+                is_executable: Callable[[str], bool] = _is_executable, listdir: Callable[[str], list[str]] = _listdir) -> dict:
     env = os.environ if env is None else env
     platform = sys.platform if platform is None else platform
     home = str(Path.home()) if home is None else home
     win = platform == "win32"
-    dirs = search_dirs(env=env, platform=platform, home=home)
+    dirs = search_dirs(env=env, platform=platform, home=home, listdir=listdir)
     exts = [""] + [e.lower() for e in (env.get("PATHEXT") or ".COM;.EXE;.BAT;.CMD").split(";") if e] if win else [""]
 
     def join(d: str, b: str) -> str:

{witbitz_code-1.3.6 → 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.6 → witbitz_code-1.3.8}/src/witbitz_code/uninstall.py

@@ -150,8 +150,43 @@ def opencode_holders(data_dir: str) -> list[dict]:
     return hits
 
 
+def _win_alive(pid: int) -> bool:
+    """Windows: is `pid` still running? (OpenProcess + GetExitCodeProcess; access denied = another user's, still running.)"""
+    import ctypes  # noqa: PLC0415 — Windows only
+
+    k = ctypes.windll.kernel32  # type: ignore[attr-defined]
+    h = k.OpenProcess(0x1000, False, pid)  # PROCESS_QUERY_LIMITED_INFORMATION
+    if not h:
+        return k.GetLastError() == 5  # ERROR_ACCESS_DENIED
+    try:
+        code = ctypes.c_ulong()
+        return bool(k.GetExitCodeProcess(h, ctypes.byref(code))) and code.value == 259  # STILL_ACTIVE
+    finally:
+        k.CloseHandle(h)
+
+
+def win_stop_process(pid: int, *, run: Callable[[list[str]], Any] | None = None, alive: Callable[[int], bool] = _win_alive,
+                     sleep: Callable[[float], None] = time.sleep) -> bool:
+    """Windows: taskkill /T /F (the process and what it started — a witbitz-code serve's OpenCode goes with it), then wait up
+    to 5 s for it to be gone. Never os.kill(pid, 0): on Windows signal 0 is CTRL_C_EVENT, a Ctrl-C to the console's
+    processes — setup's own window included — not a probe."""
+    run = run or (lambda argv: subprocess.run(argv, capture_output=True, check=False, timeout=30))
+    try:
+        run(["taskkill", "/PID", str(pid), "/T", "/F"])
+    except (OSError, subprocess.SubprocessError):
+        pass
+    for _ in range(50):
+        if not alive(pid):
+            return True
+        sleep(0.1)
+    return not alive(pid)
+
+
 def stop_process(pid: int) -> bool:
-    """SIGTERM, up to 5 s, then SIGKILL. Gone = no such process, or a zombie (exited, not yet reaped)."""
+    """SIGTERM, up to 5 s, then SIGKILL. Gone = no such process, or a zombie (exited, not yet reaped). Windows: win_stop_process."""
+    if sys.platform == "win32":
+        return win_stop_process(pid)
+
     def gone() -> bool:
         try:
             os.kill(pid, 0)
@@ -170,7 +205,7 @@ def stop_process(pid: int) -> bool:
         if gone():
             return True
     try:
-        os.kill(pid, getattr(signal, "SIGKILL", signal.SIGTERM))  # Windows has no SIGKILL
+        os.kill(pid, getattr(signal, "SIGKILL", signal.SIGTERM))
     except OSError:
         pass
     time.sleep(0.3)

{witbitz_code-1.3.6 → witbitz_code-1.3.8}/src/witbitz_code/winagent.py

@@ -19,6 +19,8 @@ import sys
 from pathlib import Path
 from typing import Callable
 
+from . import tools_probe
+
 INSTRUCTIONS_NAME = "witbitz-windows.md"
 
 GIT_BASH = """# This computer
@@ -70,7 +72,7 @@ def _write_once(f: Path, text: str) -> None:
 
 
 def windows_agent(config_dir: Path, env: dict | None = None, platform: str | None = None,
-                  exists: Callable[[str], bool] = os.path.exists) -> tuple[dict, str | None, str]:
+                  exists: Callable[[str], bool] = os.path.exists, listdir: Callable[[str], list] | None = None) -> tuple[dict, str | None, str]:
     """→ (env additions — PATH_PREPEND is a list for apply(), the instructions file or None, a line for the log or "")."""
     platform = sys.platform if platform is None else platform
     if platform != "win32":
@@ -84,6 +86,9 @@ def windows_agent(config_dir: Path, env: dict | None = None, platform: str | Non
     # Poppler from setup's Tools step (toolsetup.py: winget has no package, so a pinned release into Witbitz\poppler\bin)
     poppler = ntpath.join(_witbitz_dir(env), "poppler", "bin")
     prepend = [d for d in (py, poppler if exists(ntpath.join(poppler, "pdftotext.exe")) else None) if d]
+    # Tesseract and qpdf: their installers leave PATH alone (tools_probe.win_program_dirs — setup's probe looks there too)
+    programs = tools_probe.win_program_dirs(env, listdir) if listdir else tools_probe.win_program_dirs(env)
+    prepend += [d for d in programs if exists(ntpath.join(d, "tesseract.exe")) or exists(ntpath.join(d, "qpdf.exe"))]
     if prepend:
         add["PATH_PREPEND"] = prepend
     f = Path(config_dir) / INSTRUCTIONS_NAME

{witbitz_code-1.3.6 → 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.6 → 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.6
+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.6 → witbitz_code-1.3.8}/src/witbitz_code.egg-info/SOURCES.txt

@@ -70,6 +70,7 @@ tests/test_pair_flows.py
 tests/test_plugins.py
 tests/test_policy.py
 tests/test_ports.py
+tests/test_ports_win.py
 tests/test_registry.py
 tests/test_relay_codec.py
 tests/test_setup.py

{witbitz_code-1.3.6 → 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"