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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: witbitz-code
-Version: 1.3.5
+Version: 1.3.7
 Summary: Reach OpenCode on this computer from the Witbitz Spaces Code section, through an end-to-end sealed relay.
 Author: Witbitz
 License-Expression: MIT
@@ -21,6 +21,7 @@ Requires-Dist: segno>=1.5
 Requires-Dist: tinfoil<0.15,>=0.14
 Provides-Extra: test
 Requires-Dist: pytest>=8; extra == "test"
+Requires-Dist: pyflakes>=3; extra == "test"
 Dynamic: license-file
 
 # witbitz-code

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "witbitz-code"
-version = "1.3.5"
+version = "1.3.7"
 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"
@@ -29,7 +29,7 @@ dependencies = [
 ]
 
 [project.optional-dependencies]
-test = ["pytest>=8"]
+test = ["pytest>=8", "pyflakes>=3"]
 
 [project.urls]
 Documentation = "https://witbitz.chat/docs/opencode.md"

{witbitz_code-1.3.5 → witbitz_code-1.3.7}/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.5"
+__version__ = "1.3.7"

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

@@ -26,7 +26,7 @@ import httpx
 from . import __version__
 from . import pair as pair_cmd
 from . import pairings as pp
-from . import codekeys, codetools, confidential, keys, models, plugins, policy, uninstall as uninstall_mod, winagent, winconsole, wizard
+from . import codekeys, codetools, confidential, keys, models, plugins, policy, ports, toolsetup, uninstall as uninstall_mod, winagent, winconsole, wizard
 from ._js import to_number, truthy
 from .connector import pairings_for_port, start_connector
 from .payers import SessionPayers
@@ -161,6 +161,11 @@ async def serve(args: list[str]) -> int:
     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.

{witbitz_code-1.3.5 → witbitz_code-1.3.7}/src/witbitz_code/opencode_plugins/witbitz-media-server.mjs

@@ -719,26 +719,35 @@ export function parseSearchAnswer (data) { // == agent/tinfoilWebSearch.mjs pars
   }
   return { text, citations }
 }
-async function webSearch (a, { fetchImpl = fetch, env = process.env } = {}) {
-  const q = String((a && a.query) || '').replace(/\s+/g, ' ').trim().slice(0, 2000)
-  if (!q) fail('query is required')
-  const apiKey = env.TINFOIL_API_KEY
-  if (!apiKey) fail('web_search needs a Tinfoil key: TINFOIL_API_KEY is not set for this OpenCode (on a laptop it comes from ~/.opencode-server.env; a cloud computer gets it from its Sentinel)')
-  const url = env.WITBITZ_SEARCH_URL || `https://${SEARCH_HOST}${SEARCH_PATH}`
-  const body = {
+/** The one Tinfoil web-search request, for a laptop (sent with the key) and for a cloud computer's Sentinel (which builds it
+ *  from the query alone, so the key it holds cannot be spent on any other call — infra/cloud-computer/sentinel). */
+export function searchRequest (query, { piiCheck = true } = {}) {
+  return {
     model: SEARCH_MODEL,
     messages: [
       { role: 'system', content: 'You are a web research assistant. Search the web and report what you find, briefly and factually, with dates. State plainly when sources disagree or when something has not happened yet. Do not speculate beyond what the sources say.' },
-      { role: 'user', content: q },
+      { role: 'user', content: query },
     ],
     max_tokens: SEARCH_MAX_TOKENS,
     reasoning_effort: SEARCH_REASONING_EFFORT,
     web_search_options: {},
-    ...(a && a.pii_check === false ? {} : { pii_check_options: {} }), // a query carrying personal data is refused before it leaves the enclave for the index
+    ...(piiCheck === false ? {} : { pii_check_options: {} }), // a query carrying personal data is refused before it leaves the enclave for the index
   }
+}
+
+async function webSearch (a, { fetchImpl = fetch, env = process.env } = {}) {
+  const q = String((a && a.query) || '').replace(/\s+/g, ' ').trim().slice(0, 2000)
+  if (!q) fail('query is required')
+  const piiCheck = !(a && a.pii_check === false)
+  // A cloud computer holds no key: the query goes to its Credential Sentinel, which builds this same request with the key.
+  const viaSentinel = env.WITBITZ_SEARCH_SENTINEL
+  const apiKey = env.TINFOIL_API_KEY
+  if (!viaSentinel && !apiKey) fail('web_search needs a Tinfoil key: TINFOIL_API_KEY is not set for this OpenCode (on a laptop it comes from ~/.opencode-server.env; a cloud computer gets it from its Sentinel)')
+  const url = viaSentinel || env.WITBITZ_SEARCH_URL || `https://${SEARCH_HOST}${SEARCH_PATH}`
+  const body = viaSentinel ? { query: q, pii_check: piiCheck } : searchRequest(q, { piiCheck })
   let data
   try {
-    const res = await fetchImpl(url, { method: 'POST', headers: { 'content-type': 'application/json', authorization: `Bearer ${apiKey}` }, body: JSON.stringify(body), signal: AbortSignal.timeout(SEARCH_TIMEOUT_MS) })
+    const res = await fetchImpl(url, { method: 'POST', headers: { 'content-type': 'application/json', ...(viaSentinel ? {} : { authorization: `Bearer ${apiKey}` }) }, body: JSON.stringify(body), signal: AbortSignal.timeout(SEARCH_TIMEOUT_MS) })
     if (!res.ok) fail(`the search endpoint answered ${res.status}`)
     data = await res.json()
   } catch (e) { fail(`could not search the web (${String((e && e.message) || e).slice(0, 160)})`) }

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

@@ -3,19 +3,25 @@
 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; elsewhere nothing is known and setup says the port is taken.
+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"):
@@ -85,3 +91,49 @@ def on_wsl() -> bool:
         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

{witbitz_code-1.3.5 → witbitz_code-1.3.7}/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.5 → witbitz_code-1.3.7}/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.5 → witbitz_code-1.3.7}/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.5 → witbitz_code-1.3.7}/src/witbitz_code/wizard.py

@@ -241,7 +241,7 @@ def _describe(step: dict) -> str:
 
 
 async def _tools_step(d: Deps) -> str:
-    """→ 'here' | 'installed' | 'partly' | 'skipped' | 'unavailable'."""
+    """→ 'here' | 'installed' | 'partly' | 'skipped' | 'unavailable' | 'failed' (an install that breaks never ends setup)."""
     try:
         report = d.probe_tools()
     except Exception:  # noqa: BLE001 — a probe that fails never stops setup
@@ -262,8 +262,12 @@ async def _tools_step(d: Deps) -> str:
     if not _yes(d.ask("   Install them now? [Y/n] ")):
         d.say("   Skipped — run witbitz-code setup again to install them, or use the card in Code.")
         return "skipped"
-    d.run_tools(plan)
-    d.refresh_path()
+    try:
+        d.run_tools(plan)
+        d.refresh_path()
+    except Exception as e:  # noqa: BLE001 — the tools are a convenience: setup goes on to serve
+        d.say(f"   Could not install them ({str(e)[:160]}) — setup goes on; \"Install with the agent\" in Code can try.")
+        return "failed"
     try:
         after = {t["id"] for t in toolsetup.missing_tools(d.probe_tools())}
     except Exception:  # noqa: BLE001

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: witbitz-code
-Version: 1.3.5
+Version: 1.3.7
 Summary: Reach OpenCode on this computer from the Witbitz Spaces Code section, through an end-to-end sealed relay.
 Author: Witbitz
 License-Expression: MIT
@@ -21,6 +21,7 @@ Requires-Dist: segno>=1.5
 Requires-Dist: tinfoil<0.15,>=0.14
 Provides-Extra: test
 Requires-Dist: pytest>=8; extra == "test"
+Requires-Dist: pyflakes>=3; extra == "test"
 Dynamic: license-file
 
 # witbitz-code

{witbitz_code-1.3.5 → witbitz_code-1.3.7}/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.5 → witbitz_code-1.3.7}/src/witbitz_code.egg-info/requires.txt

@@ -6,3 +6,4 @@ tinfoil<0.15,>=0.14
 
 [test]
 pytest>=8
+pyflakes>=3

witbitz_code-1.3.7/tests/test_ports_win.py

@@ -0,0 +1,83 @@
+"""Windows: who holds a port (netstat + tasklist) and stopping it without os.kill(pid, 0) — measured on the owner's laptop,
+2026-10-09: setup called their own `witbitz-code serve` "a program that is not yours" (Windows knew nobody)."""
+
+from __future__ import annotations
+
+import os
+import sys
+
+from conftest import requires_node, run_node
+
+from witbitz_code import ports, uninstall
+
+NETSTAT = """
+Active Connections
+
+  Proto  Local Address          Foreign Address        State           PID
+  TCP    0.0.0.0:135            0.0.0.0:0              LISTENING       1100
+  TCP    127.0.0.1:4096         0.0.0.0:0              ABHÖREN         7001
+  TCP    127.0.0.1:4096         127.0.0.1:52011        ESTABLISHED     7001
+  TCP    127.0.0.1:52011        127.0.0.1:4096         ESTABLISHED     9999
+  TCP    127.0.0.1:4196         0.0.0.0:0              LISTENING       7002
+  TCP    [::1]:4096             [::]:0                 LISTENING       7003
+  TCP    127.0.0.1:40960        0.0.0.0:0              LISTENING       7004
+  UDP    0.0.0.0:4096           *:*                                    7005
+"""
+
+TASKLIST = {
+    7001: '"opencode.exe","7001","Console","1","120,404 K","Running","LAPTOP\\shter","0:00:03","N/A"',
+    7002: '"python.exe","7002","Console","1","80,000 K","Running","LAPTOP\\Shter","0:00:01","witbitz-code serve"',
+    7003: '"other.exe","7003","Services","0","9,000 K","Unknown","N/A","0:00:00","N/A"',
+}
+
+
+def fake_run(argv: list[str]) -> str:
+    if argv[0] == "netstat":
+        return NETSTAT
+    pid = int(argv[-1].split()[-1])
+    return TASKLIST.get(pid, "INFO: No tasks are running which match the specified criteria.")
+
+
+def test_the_listening_processes_are_read_by_address_not_by_the_translated_state():
+    assert ports.parse_netstat_listeners(NETSTAT, 4096) == [7001, 7003]
+    assert ports.parse_netstat_listeners(NETSTAT, 4196) == [7002]
+    assert ports.parse_netstat_listeners(NETSTAT, 52011) == [], "a connection's port is not a listener"
+
+
+def test_only_this_users_programs_are_named_and_never_this_process():
+    assert ports.win_owners(4096, run=fake_run, user="shter", self_pid=1) == [{"pid": 7001, "cmd": "opencode.exe"}]
+    assert ports.win_owners(4196, run=fake_run, user="shter", self_pid=1) == [{"pid": 7002, "cmd": "python.exe"}]
+    assert ports.win_owners(4196, run=fake_run, user="shter", self_pid=7002) == []
+    assert ports.parse_tasklist_row("INFO: No tasks are running which match the specified criteria.") is None
+
+
+@requires_node
+def test_the_javascript_reads_the_same():
+    js = run_node("""
+      import { parseNetstatListeners, winPortOwners } from '@TOOLS@/code-ports-win.mjs'
+      const run = (argv) => argv[0] === 'netstat' ? INPUT.netstat : (INPUT.tasklist[argv[argv.length - 1].split(' ').pop()] || 'INFO: none')
+      OUT({ l: [4096, 4196, 52011].map((p) => parseNetstatListeners(INPUT.netstat, p)),
+            o: [[4096, 1], [4196, 1], [4196, 7002]].map(([p, self]) => winPortOwners(p, { run, user: 'shter', self })) })
+    """, {"netstat": NETSTAT, "tasklist": {str(k): v for k, v in TASKLIST.items()}})
+    assert js["l"] == [ports.parse_netstat_listeners(NETSTAT, p) for p in (4096, 4196, 52011)]
+    assert js["o"] == [ports.win_owners(p, run=fake_run, user="shter", self_pid=s) for p, s in ((4096, 1), (4196, 1), (4196, 7002))]
+
+
+def test_stopping_on_windows_is_taskkill_of_the_tree_and_never_os_kill(monkeypatch):
+    def no_kill(*a):
+        raise AssertionError("os.kill on Windows: signal 0 is CTRL_C_EVENT — a Ctrl-C to setup's own window")
+
+    monkeypatch.setattr(os, "kill", no_kill)
+    ran, left = [], [3]
+
+    def alive(pid: int) -> bool:
+        left[0] -= 1
+        return left[0] > 0
+
+    assert uninstall.win_stop_process(4242, run=ran.append, alive=alive, sleep=lambda s: None) is True
+    assert ran == [["taskkill", "/PID", "4242", "/T", "/F"]]
+    assert uninstall.win_stop_process(4243, run=lambda a: None, alive=lambda p: True, sleep=lambda s: None) is False
+    stopped = []
+    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]

{witbitz_code-1.3.5 → witbitz_code-1.3.7}/tests/test_tools_probe.py

@@ -100,3 +100,31 @@ def test_the_connector_answers_tools_with_the_current_nonce_only(make, tmp_path)
                 await connector.stop()
 
     run(go())
+
+
+WIN_DIRS_JS = """
+  import { probeTools } from '@TOOLS@/code-tools-probe.mjs'
+  const files = new Set(INPUT.files)
+  OUT(probeTools({ env: INPUT.env, platform: 'win32', home: '', isExecutable: (p) => files.has(p), listdir: (d) => INPUT.dirs[d] || [] }))
+"""
+
+
+def test_tesseract_and_qpdf_are_found_where_their_installers_put_them_off_path():
+    # the owner's laptop, 2026-10-09: winget installed both, PATH has neither, setup said "Still missing: qpdf, Tesseract"
+    env = {"PATH": "C:\\Windows\\System32", "ProgramFiles": "C:\\Program Files", "ProgramFiles(x86)": "C:\\Program Files (x86)",
+           "LOCALAPPDATA": "C:\\Users\\u\\AppData\\Local"}
+    dirs = {"C:\\Program Files": ["Git", "qpdf 12.4.2", "Tesseract-OCR"], "C:\\Users\\u\\AppData\\Local\\Programs": ["qpdf"]}
+    files = ["C:\\Program Files\\Tesseract-OCR\\tesseract.exe", "C:\\Program Files\\qpdf 12.4.2\\bin\\qpdf.exe"]
+    got = probe_tools(env=env, platform="win32", home="", is_executable=set(files).__contains__, listdir=lambda d: dirs.get(d, []))
+    assert got["tools"]["tesseract"] and got["tools"]["qpdf"]
+    none = probe_tools(env=env, platform="win32", home="", is_executable=lambda p: False, listdir=lambda d: dirs.get(d, []))
+    assert not none["tools"]["tesseract"] and not none["tools"]["qpdf"]
+
+
+@requires_node
+def test_the_javascript_probe_looks_in_the_same_program_folders():
+    env = {"PATH": "", "ProgramFiles": "C:\\Program Files\\", "ProgramW6432": "C:\\Program Files", "LOCALAPPDATA": "C:\\L"}
+    dirs = {"C:\\Program Files": ["QPDF 11", "qpdf 12.4.2"], "C:\\L\\Programs": ["Tesseract-OCR", "qpdf-x"]}
+    for files in (["C:\\Program Files\\QPDF 11\\bin\\qpdf.exe"], ["C:\\L\\Programs\\Tesseract-OCR\\tesseract.EXE"], ["C:\\L\\Programs\\qpdf-x\\bin\\qpdf.exe"], []):
+        js = run_node(WIN_DIRS_JS, {"env": env, "dirs": dirs, "files": files})
+        assert probe_tools(env=env, platform="win32", home="", is_executable=set(files).__contains__, listdir=lambda d: dirs.get(d, [])) == js, files

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

@@ -145,3 +145,61 @@ def test_no_package_manager_says_so_without_asking():
     t = Tools(["jq"], {"os": "darwin", "pm": ""})
     r, said = step(t, [])
     assert r == "unavailable" and t.plans == [] and any("no package manager found" in s for s in said)
+
+
+def test_an_install_that_breaks_never_ends_setup():
+    # 1.3.5 on Windows: cli.py never imported toolsetup, so the first "y" died "FATAL — name 'toolsetup' is not defined"
+    t = Tools(["jq"], {"os": "win32", "pm": "winget"})
+
+    def broken(plan: list) -> dict:
+        raise NameError("name 'toolsetup' is not defined")
+
+    t.run = broken  # type: ignore[method-assign]
+    r, said = step(t, [""])
+    assert r == "failed"
+    assert any("Could not install them (name 'toolsetup' is not defined) — setup goes on" in s for s in said)
+
+
+def test_setup_hands_the_wizard_the_real_installer_and_path_refresh(monkeypatch):
+    # the wizard's own tests fake run_tools/refresh_path, so only this one runs the lambdas cli.py builds
+    from witbitz_code import cli
+
+    seen: dict = {}
+
+    async def capture(d):
+        seen["d"] = d
+        return {"served": 0}
+
+    monkeypatch.setattr(wizard, "run_setup", capture)
+    asyncio.run(cli.setup([]))
+    seen["d"].refresh_path()
+    assert seen["d"].run_tools([]) == {"done": [], "failed": [], "auto": [], "none": []}
+
+
+def test_no_module_uses_a_name_it_never_defined():
+    # pyflakes: the two missing imports that reached a release (ports in 1.3.3's serve, toolsetup in 1.3.5's setup)
+    from pathlib import Path
+
+    import pyflakes.api
+    import pyflakes.messages
+
+    import witbitz_code
+
+    class Undefined:
+        def __init__(self) -> None:
+            self.found: list[str] = []
+
+        def unexpectedError(self, filename, msg):  # noqa: N802 — pyflakes' reporter interface
+            self.found.append(f"{filename}: {msg}")
+
+        def syntaxError(self, filename, msg, lineno, offset, text):  # noqa: N802
+            self.found.append(f"{filename}:{lineno}: {msg}")
+
+        def flake(self, message):
+            if isinstance(message, pyflakes.messages.UndefinedName):
+                self.found.append(str(message))
+
+    rep = Undefined()
+    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 == []

{witbitz_code-1.3.5 → witbitz_code-1.3.7}/tests/test_winagent.py

@@ -77,3 +77,14 @@ def test_setups_poppler_joins_the_agents_path_when_it_is_there(tmp_path):
     assert add["PATH_PREPEND"] == [r"C:\Users\t\AppData\Local\Witbitz\agent-python\Scripts", r"C:\Users\t\AppData\Local\Witbitz\poppler\bin"]
     add2, _, _ = winagent.windows_agent(tmp_path, env=ENV, platform="win32", exists=exists_of(py))
     assert add2["PATH_PREPEND"] == [r"C:\Users\t\AppData\Local\Witbitz\agent-python\Scripts"]
+
+
+def test_tesseract_and_qpdf_join_the_agents_path_where_their_installers_put_them(tmp_path):
+    # the owner's laptop, 2026-10-09: winget installed both and neither installer touches PATH
+    env = {**ENV, "ProgramFiles": r"C:\Program Files"}
+    tess, qpdf = r"C:\Program Files\Tesseract-OCR\tesseract.exe", r"C:\Program Files\qpdf 12.4.2\bin\qpdf.exe"
+    listdir = {r"C:\Program Files": ["qpdf 12.4.2", "Tesseract-OCR"]}.get
+    add, _, _ = winagent.windows_agent(tmp_path, env=env, platform="win32", exists=exists_of(tess, qpdf), listdir=lambda d: listdir(d, []))
+    assert add["PATH_PREPEND"] == [r"C:\Program Files\Tesseract-OCR", r"C:\Program Files\qpdf 12.4.2\bin"]
+    none, _, _ = winagent.windows_agent(tmp_path, env=env, platform="win32", exists=exists_of(), listdir=lambda d: listdir(d, []))
+    assert "PATH_PREPEND" not in none