witbitz-code 1.5.0__tar.gz → 1.6.0__tar.gz

{witbitz_code-1.5.0/src/witbitz_code.egg-info → witbitz_code-1.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: witbitz-code
-Version: 1.5.0
+Version: 1.6.0
 Summary: Reach OpenCode on this computer from the Witbitz Spaces Code section, through an end-to-end sealed relay.
 Author: Witbitz
 License-Expression: MIT

{witbitz_code-1.5.0 → witbitz_code-1.6.0}/pyproject.toml

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

{witbitz_code-1.5.0 → witbitz_code-1.6.0}/src/witbitz_code/cli.py

@@ -26,17 +26,20 @@ 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, ports, toolsetup, uninstall as uninstall_mod, winagent, winconsole, wizard
+from . import codekeys, codetools, confidential, keys, models, plugins, policy, ports, toolsetup, uninstall as uninstall_mod, winagent, winbg, winconsole, wizard, wslstart
 from ._js import to_number, truthy
 from .connector import pairings_for_port, start_connector
 from .payers import SessionPayers
 
 HELP = f"""witbitz-code {__version__} — reach OpenCode on this computer from the Spaces Code section, end-to-end encrypted.
 
-  setup [--port <n>]           start here: installs OpenCode if needed, pairs this computer — which gives it its own
-                               keys from your Spaces account — then serves
-  ui [--no-browser]            the same in a page in your browser: status, pair / unpair / pair again, start and stop,
-                               start when I log in (Windows and WSL); it serves while its window is open
+  setup [--port <n>] [--here]  start here: installs OpenCode if needed, pairs this computer — which gives it its own
+                               keys from your Spaces account — then serves. Windows and WSL: after OpenCode, the page
+                               opens and does the rest, in the background (--here: every step in this terminal)
+  ui [--no-browser] [--background]
+                               the same in a page in your browser: status, pair / unpair / pair again, start and stop,
+                               start when I log in (Windows and WSL); it serves while it runs. --background (Windows):
+                               no window — the page's Quit stops it
   pair [--name <name>]         show a QR code; scan it in Spaces (Settings → Back up & recovery → Add a device)
   serve [--port <n>] [--no-opencode]
                                start OpenCode on 127.0.0.1 with your account's keys, and the connector
@@ -327,6 +330,8 @@ async def setup(args: list[str]) -> int:
         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)]),
+        background_ui=None if "--here" in args else (lambda: winbg.launch_ui()) if sys.platform == "win32"
+        else (lambda: wslstart.launch_background()) if ports.on_wsl() else None,
     )
     try:
         r = await wizard.run_setup(d)
@@ -392,6 +397,10 @@ async def ui_command(args: list[str]) -> int:
     start when I log in. It runs serve inside itself; --no-browser serves without opening the page (a login start)."""
     from . import net, ui  # noqa: PLC0415
 
+    if "--background" in args:  # Windows: hand off to a windowless copy (winbg.py) and return — this window may close
+        ok, why = winbg.launch_ui([a for a in args if a != "--background"])
+        _err("witbitz-code: running in the background — it opens in your browser" if ok else f"witbitz-code: could not start it in the background: {why}")
+        return 0 if ok else 1
     http = net.new_client()
     keys = pair_cmd._KeyCalls(http)
     try:

{witbitz_code-1.5.0 → witbitz_code-1.6.0}/src/witbitz_code/ui.py

@@ -35,7 +35,7 @@ from importlib import resources
 from pathlib import Path
 from typing import Any, Awaitable, Callable
 
-from . import __version__, devicelink, link, net, ports, qr, wizard, wslstart
+from . import __version__, devicelink, link, net, ports, qr, uitools, uninstall, winbg, wizard, wslstart
 from . import pair as pair_cmd
 from . import pairings as pp
 
@@ -91,7 +91,7 @@ class _Tee(io.TextIOBase):
         while "\n" in self._part:
             line, self._part = self._part.split("\n", 1)
             if line.strip() and "\x1b[" not in line:
-                self.sink.append(line.rstrip()[:300])
+                self.sink.append(line.rstrip()[:600])
         return len(s)
 
     def flush(self) -> None:
@@ -122,9 +122,14 @@ class Manager:
                  login_state: Callable[[dict], str] = wslstart.startup_state,
                  login_enable: Callable[[dict], tuple] = wslstart.startup_enable,
                  login_disable: Callable[[dict], bool] = wslstart.startup_disable,
-                 label: dict | None = None, log: deque | None = None) -> None:
+                 port_owners: Callable[[int], list] | None = None, stop_pid: Callable[[int], bool] | None = None,
+                 tools: uitools.Tools | None = None, label: dict | None = None, log: deque | None = None) -> None:
         self._serve, self._is_listening, self._pair, self._link = serve, is_listening, pair, link_node
         self._load, self._keys_line = load_pairings, keys_line
+        self.tools = tools or uitools.Tools()
+        self._owners = port_owners or ports.port_owners
+        self._stop_pid = stop_pid or uninstall.stop_process
+        self._elsewhere_cache: tuple[float, dict | None] | None = None
         self._login_spec, self._login_state, self._login_enable, self._login_disable = login_spec, login_state, login_enable, login_disable
         self.label = label or computer_label()
         self.log: deque = log if log is not None else deque(maxlen=60)
@@ -139,6 +144,8 @@ class Manager:
         self._keys_cache: dict[str, tuple[float, str]] = {}
         self._login_cache: tuple[float, dict] | None = None
         self.busy = ""  # the action running now (the page greys its buttons)
+        self.background = False  # Windows, no window (winbg.py): the page's Quit is the only way to stop it
+        self.quit_event: asyncio.Event | None = None
 
     # ── reading ────────────────────────────────────────────────────────────────────────────────────────────────────────
     def pairings(self) -> list:
@@ -196,15 +203,67 @@ class Manager:
         for p in ps:
             paired.append({"name": p.get("name") or "", "account": p.get("account") or "", "port": wizard.port_of(p), "keys": await self.keys(p)})
         pair = {k: v for k, v in self.pair_state.items() if k != "log"}
-        return {"version": __version__, "computer": self.label, "paired": paired, "serving": self.serving(), "pair": pair,
-                "login": self.login(), "busy": self.busy, "log": list(self.log)[-14:]}
+        serving = self.serving()
+        if serving["state"] == "stopped" and ps:
+            el = await self.elsewhere()
+            if el:
+                serving = {"state": "elsewhere", "port": el["port"], "owners": el["owners"]}
+        return {"version": __version__, "computer": self.label, "paired": paired, "serving": serving, "pair": pair,
+                "login": self.login(), "busy": self.busy, "background": self.background,
+                "tools": await asyncio.to_thread(self.tools.status), "log": list(self.log)[-14:]}
+
+    async def elsewhere(self, fresh: bool = False) -> dict | None:
+        """{port, owners} when THIS person's other process holds OpenCode's port or the model proxy's (port + 100) while this
+        page serves nothing — `witbitz-code setup` serving in its own window, a login-started copy, an earlier serve (the owner,
+        2026-10-09: the installer's setup was serving and the page said Stopped; its Start then failed "held by python.exe").
+        Another user's program, or WSL's copy (Windows cannot name it), is not listed: Start then fails and says why."""
+        if self.serve_task and not self.serve_task.done():
+            return None
+        hit = self._elsewhere_cache
+        if hit and not fresh and time.monotonic() - hit[0] < 5:
+            return hit[1]
+        port, owners = self.port(), []
+        for q in (port, port + 100):
+            if not await self._is_listening(q):
+                continue
+            try:
+                found = await asyncio.to_thread(self._owners, q)
+            except Exception:  # noqa: BLE001 — a reading, never a failure of the page
+                found = []
+            for o in found:
+                if all(o["pid"] != x["pid"] for x in owners):
+                    owners.append({"pid": int(o["pid"]), "cmd": str(o.get("cmd") or "")[:80]})
+        out = {"port": port, "owners": owners} if owners else None
+        self._elsewhere_cache = (time.monotonic(), out)
+        return out
+
+    async def _stop_elsewhere(self, el: dict) -> list[str]:
+        """Stop what elsewhere() named, then wait (≤ 6 s) for both ports to come free. The lines that say what happened."""
+        said = []
+        for o in el["owners"]:
+            ok = await asyncio.to_thread(self._stop_pid, o["pid"])
+            said.append(f"{'stopped' if ok else 'could not stop'} {o['cmd'] or 'a program'} (process {o['pid']})")
+            self.log.append("witbitz-code: " + said[-1])
+        for _ in range(30):
+            if not [q for q in (el["port"], el["port"] + 100) if await self._is_listening(q)]:
+                break
+            await asyncio.sleep(0.2)
+        self._elsewhere_cache = None
+        return said
 
     # ── serving ────────────────────────────────────────────────────────────────────────────────────────────────────────
-    async def start_serving(self) -> dict:
+    async def start_serving(self, takeover: bool = False) -> dict:
+        """Serve from this page. Another copy of witbitz-code already serving here: the page's Start (takeover) stops it
+        and runs here instead; the launch's own start leaves it alone (the page then shows where it runs)."""
         if self.serve_task and not self.serve_task.done():
             return {"ok": True}
         if not self.pairings():
             return {"ok": False, "why": "pair this computer first"}
+        el = await self.elsewhere(fresh=True)
+        if el and not takeover:
+            return {"ok": False, "why": "already running in another window", "elsewhere": el}
+        if el:
+            await self._stop_elsewhere(el)
         self.serve_stop, self.serve_exit, self.live = _StopFlag(), None, {}
         self.serve_port = self.port()
         self.serve_task = asyncio.ensure_future(self._serve_run(self.serve_port))
@@ -216,7 +275,7 @@ class Manager:
         except asyncio.CancelledError:
             raise
         except Exception as e:  # noqa: BLE001
-            self.serve_exit = {"code": 1, "why": str(e)[:200]}
+            self.serve_exit = {"code": 1, "why": str(e)[:500]}
             return 1
         last = next((ln for ln in reversed(self.log) if ln.startswith("witbitz-code:")), "")
         self.serve_exit = {"code": code, "why": "" if code == 0 else last.replace("witbitz-code: ", "", 1)}
@@ -225,6 +284,9 @@ class Manager:
     async def stop_serving(self) -> dict:
         t = self.serve_task
         if t is None or t.done():
+            el = await self.elsewhere(fresh=True)
+            if el:
+                return {"ok": True, "said": await self._stop_elsewhere(el)}
             return {"ok": True}
         self.serve_stop.event.set()
         try:
@@ -323,6 +385,13 @@ class Manager:
         self._login_cache = None
         return {"ok": bool(ok), **({"why": why} if not ok else {})}
 
+    async def quit(self) -> dict:
+        """Stop serving and end this manager (the page's Quit — in the background there is no window to close)."""
+        await self.stop_serving()
+        if self.quit_event:
+            asyncio.get_running_loop().call_later(0.3, self.quit_event.set)  # after this answer reaches the page
+        return {"ok": True}
+
     async def shutdown(self) -> None:
         if self.pair_task and not self.pair_task.done():
             self.pair_task.cancel()
@@ -455,11 +524,13 @@ class Server:
             return 400, {"content-type": "application/json"}, b'{"error":"not json"}'
         data = data if isinstance(data, dict) else {}
         actions: dict[str, Callable[[], Awaitable[dict]]] = {
-            "/api/serve": lambda: self.m.start_serving() if data.get("on") else self.m.stop_serving(),
+            "/api/serve": lambda: self.m.start_serving(takeover=True) if data.get("on") else self.m.stop_serving(),
             "/api/pair": self.m.start_pairing,
             "/api/pair/cancel": self.m.cancel_pairing,
             "/api/unpair": lambda: self.m.unpair(str(data.get("account") or "")),
             "/api/login": lambda: self.m.set_login(bool(data.get("on"))),
+            "/api/quit": self.m.quit,
+            "/api/tools/install": self.m.tools.install,
         }
         act = actions.get(path)
         if not act:
@@ -509,22 +580,29 @@ async def run(args: list[str], *, serve: Callable[..., Awaitable[int]], is_liste
         if not no_browser:
             open_browser(url)
         return 0
+    background = winbg.prepare(lock_path().parent / "ui.log")  # Windows, pythonw: a log file, windowless children
+    if "--hidden" in args and not background:  # WSL, started by a hidden wsl.exe (wslstart.py): no window either
+        winbg.log_to(lock_path().parent / "ui.log")
+        background = True
     log: deque = deque(maxlen=60)
     tee = _Tee(sys.stderr, log)
     old_err = sys.stderr
     sys.stderr = tee
     m = Manager(serve=serve, is_listening=is_listening, keys_line=keys_line, log=log)
+    m.background = background
+    stop = asyncio.Event()
+    m.quit_event = stop
     srv = Server(m)
     try:
         await srv.start()
         pp.write_private(lock_path(), json.dumps({"port": srv.port, "token": srv.token, "pid": os.getpid()}) + "\n")
         print(f"witbitz-code: {m.label['label']} — open {srv.url}", file=sys.stderr, flush=True)
-        print("witbitz-code: keep this window open (closing it stops witbitz-code). Ctrl-C stops it.", file=sys.stderr, flush=True)
+        print("witbitz-code: running in the background — Quit on the page stops it" if background else
+              "witbitz-code: keep this window open (closing it stops witbitz-code). Ctrl-C stops it.", file=sys.stderr, flush=True)
         if m.pairings():
             await m.start_serving()
         if not no_browser and not open_browser(srv.url):
             print("witbitz-code: open the address above in your browser", file=sys.stderr, flush=True)
-        stop = asyncio.Event()
         loop = asyncio.get_running_loop()
         import signal  # noqa: PLC0415
         for sig in (signal.SIGINT, signal.SIGTERM):

{witbitz_code-1.5.0 → witbitz_code-1.6.0}/src/witbitz_code/ui_static/app.css

@@ -49,3 +49,5 @@ pre { white-space: pre-wrap; overflow-wrap: anywhere; font: 12px/1.45 ui-monospa
 footer { font-size: 13px; text-align: center; }
 @media (prefers-reduced-motion: reduce) { * { transition: none !important; } }
 .actions:not(:has(button:not([hidden]))) { display: none; }
+button.small { font-size: 13px; padding: 2px 10px; margin-left: 8px; }
+pre.cmd { background: var(--off-bg); color: var(--text); padding: 8px 10px; border-radius: 8px; }

{witbitz_code-1.5.0 → witbitz_code-1.6.0}/src/witbitz_code/ui_static/app.js

@@ -31,11 +31,19 @@ const PILL = {
   connecting: ['Connecting…', 'connecting', 'reaching the relay'],
   starting: ['Starting…', 'starting', 'starting OpenCode'],
   stopped: ['Stopped', '', 'not reachable from Spaces'],
+  elsewhere: ['Running in another window', 'online', ''],
+}
+
+// Another copy of witbitz-code serves this computer (setup's window, a login-started one): say which, so Start/Stop make sense.
+function elsewhereText(sv) {
+  const who = (sv.owners || []).map((o) => `${o.cmd || 'a program'} (process ${o.pid})`).join(', ')
+  return `witbitz-code is running in another window${who ? ' — ' + who : ''}. Run it here to manage it from this page, or Stop it.`
 }
 
 function render(s) {
   state = s
   $('computer').textContent = s.computer.label + (s.computer.kind && !s.computer.label.includes(s.computer.kind) ? ' · ' + s.computer.kind : '')
+  document.title = s.computer.kind && s.computer.kind.startsWith('WSL') ? `Witbitz Code (${s.computer.kind})` : 'Witbitz Code'
   $('version').textContent = s.version
   const paired = s.paired.length > 0
   const run = s.serving.state
@@ -43,7 +51,7 @@ function render(s) {
   const pill = $('pill')
   pill.textContent = label
   pill.className = 'pill ' + cls
-  $('stateText').textContent = run === 'stopped' && s.serving.why ? s.serving.why : hint + (s.serving.port && s.serving.port !== 4096 ? ` · port ${s.serving.port}` : '')
+  $('stateText').textContent = run === 'elsewhere' ? elsewhereText(s.serving) : run === 'stopped' && s.serving.why ? s.serving.why : hint + (s.serving.port && s.serving.port !== 4096 ? ` · port ${s.serving.port}` : '')
 
   const list = $('paired')
   list.textContent = ''
@@ -58,7 +66,8 @@ function render(s) {
   const waiting = s.pair.state === 'waiting'
   const busy = !!s.busy
   show($('pair'), !paired && !waiting)
-  show($('start'), paired && run === 'stopped' && !waiting)
+  show($('start'), paired && (run === 'stopped' || run === 'elsewhere') && !waiting)
+  $('start').textContent = run === 'elsewhere' ? 'Run it here' : 'Start'
   show($('stop'), paired && run !== 'stopped')
   show($('pairAgain'), paired && !waiting)
   show($('unpair'), paired && !waiting)
@@ -83,6 +92,11 @@ function render(s) {
   $('login').disabled = busy || !lg.available
   $('login').checked = !!lg.on
   if (!lg.available && lg.why) $('loginNote').textContent = 'Not available: ' + lg.why
+  else if (s.background) $('loginNote').textContent = 'Starts in the background when you log in and keeps this computer reachable.'
+  // Windows, no window (winbg.py): nothing to keep open — Quit is how it stops
+  $('footerText').textContent = s.background ? 'runs in the background — Start menu → Witbitz Code opens this page' : 'keep its window open — closing it stops witbitz-code'
+  show($('quit'), !!s.background)
+  renderTools(s.tools, paired)
 
   $('log').textContent = (s.log || []).join('\n')
 }
@@ -97,7 +111,8 @@ async function refresh() {
   } catch (e) {
     $('pill').textContent = 'Not running'
     $('pill').className = 'pill bad'
-    $('stateText').textContent = 'Witbitz Code’s window was closed — open it again from the Start menu.'
+    $('stateText').textContent = quitting || (state && state.background) ? 'Witbitz Code is not running — open it again from the Start menu.'
+      : 'Witbitz Code’s window was closed — open it again from the Start menu.'
   }
 }
 
@@ -123,7 +138,41 @@ function accountOf() {
   return pick || null
 }
 
+// setup's Tools step, on the page (uitools.py): what is missing, what Install runs, its progress.
+function renderTools(t, paired) {
+  if (!t) return show($('toolsCard'), false)
+  const missing = t.missing || []
+  const running = t.state === 'installing'
+  show($('toolsCard'), paired && (missing.length > 0 || running || t.state === 'done' || !!t.error))
+  $('toolsText').textContent = t.error ? t.error
+    : running ? 'Installing…'
+    : missing.length ? `Missing here: ${missing.join(', ')}. The agent uses them to work with your files.`
+    : 'Everything the agent uses for these is here ✓'
+  const steps = t.steps || []
+  show($('toolsSteps'), !running && missing.length > 0 && steps.length > 0)
+  $('toolsSteps').textContent = steps.join('\n')
+  show($('toolsInstall'), !running && !!t.installable)
+  $('toolsInstall').disabled = !!state.busy
+  show($('toolsAdmin'), !!t.admin && !running)
+  show($('toolsAdminCmd'), !!t.admin && !running)
+  $('toolsAdminCmd').textContent = t.admin || ''
+  const lines = t.lines || []
+  show($('toolsLog'), lines.length > 0)
+  $('toolsLog').textContent = lines.join('\n')
+}
+
+let quitting = false
+async function quit() {
+  if (!window.confirm('Quit Witbitz Code? Code in Spaces will not reach this computer until you open Witbitz Code from the Start menu again.')) return
+  quitting = true
+  try { await api('/api/quit', {}) } catch { /* it is going away */ }
+  note('Witbitz Code stopped. Start menu → Witbitz Code starts it again.', 'bad')
+  for (const id of ['pair', 'start', 'stop', 'pairAgain', 'unpair', 'quit']) $(id).disabled = true
+}
+
 document.addEventListener('DOMContentLoaded', () => {
+  $('quit').onclick = quit
+  $('toolsInstall').onclick = () => act('/api/tools/install', {}, 'Install them now? Windows may ask once to allow an installer.')
   $('pair').onclick = () => act('/api/pair', {})
   $('start').onclick = () => act('/api/serve', { on: true })
   $('stop').onclick = () => act('/api/serve', { on: false }, 'Stop? Code in Spaces will not reach this computer until you start it again.')

{witbitz_code-1.5.0 → witbitz_code-1.6.0}/src/witbitz_code/ui_static/index.html

@@ -41,6 +41,16 @@
     <div class="actions"><button id="pairCancel" type="button" class="ghost">Cancel</button><button id="pairRetry" type="button" hidden>Show a new code</button></div>
   </section>
 
+  <section class="card" id="toolsCard" hidden>
+    <h2>Tools for audio, video, PDFs and scans</h2>
+    <p id="toolsText" class="muted"></p>
+    <pre id="toolsSteps" class="cmd" hidden></pre>
+    <div class="actions"><button id="toolsInstall" type="button" hidden>Install them</button></div>
+    <p id="toolsAdmin" class="muted" hidden>These need your password — run this in a terminal:</p>
+    <pre id="toolsAdminCmd" class="cmd" hidden></pre>
+    <pre id="toolsLog" class="cmd" hidden></pre>
+  </section>
+
   <section class="card" id="loginCard" hidden>
     <label class="switch-row" for="login">
       <span>
@@ -56,7 +66,8 @@
     <pre id="log"></pre>
   </details>
 
-  <footer class="muted">witbitz-code <span id="version"></span> · keep its window open — closing it stops witbitz-code</footer>
+  <footer class="muted">witbitz-code <span id="version"></span> · <span id="footerText">keep its window open — closing it stops witbitz-code</span>
+    <button id="quit" type="button" class="ghost small" hidden>Quit</button></footer>
 </main>
 </body>
 </html>

witbitz_code-1.6.0/src/witbitz_code/uitools.py

@@ -0,0 +1,108 @@
+"""The page's Tools card (ui.py): what the agent uses for audio, video, PDFs and scans, and one Install button — setup's
+Tools step without a terminal (the owner, 2026-10-09: "the installer still asks its questions in the terminal - why the
+terminal?"). The same plan as setup (toolsetup.install_plan); the same runner (toolsetup.run_plan), with each command's
+output kept for the page instead of a terminal. A step that needs an administrator's password (Linux's apt/dnf/pacman
+line) is never run from here: the page shows it for the person to run in a terminal.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import subprocess
+import time
+from collections import deque
+from collections.abc import Callable
+from typing import Any
+
+from . import toolsetup, tools_probe
+
+
+def run_captured(argv: list[str], log: Callable[[str], Any]) -> int:
+    """A command with no terminal: stdin closed, its last lines kept → its exit code (-1: it could not start)."""
+    try:
+        r = subprocess.run(argv, check=False, stdin=subprocess.DEVNULL, capture_output=True, text=True,  # noqa: S603 — argv from install_plan
+                           errors="replace", timeout=1800)
+    except (OSError, ValueError, subprocess.SubprocessError) as e:
+        log(f"   ✖ could not start it ({str(e)[:120]})")
+        return -1
+    for line in [ln.strip() for ln in (r.stdout + "\n" + r.stderr).splitlines() if ln.strip()][-4:]:
+        log("     " + line[:200])
+    return r.returncode
+
+
+def refresh_path() -> None:
+    """Windows: what winget just installed is on the registry's PATH, not yet on this process's."""
+    reg = toolsetup.registry_path()
+    if reg:
+        os.environ["PATH"] = toolsetup.merged_path(os.environ.get("PATH", ""), reg)
+
+
+def describe(step: dict) -> str:
+    if step["kind"] == "cmd":
+        return " ".join(step["argv"][:4]) if step["argv"][0] != "sh" else step["argv"][2]
+    if step["kind"] == "release":
+        return f"{toolsetup.label(step['id'])}: a {step['mb']} MB download from its publisher, checked against its SHA-256"
+    return ""
+
+
+class Tools:
+    """{state: idle|installing|done, missing, steps, admin, lines}. Everything outside is injected for tests."""
+
+    def __init__(self, *, probe: Callable[[], dict] = tools_probe.probe_tools,
+                 run_plan: Callable[..., dict] = toolsetup.run_plan, run: Callable[[list[str], Callable], int] = run_captured,
+                 refresh: Callable[[], None] = refresh_path) -> None:
+        self._probe, self._run_plan, self._run, self._refresh = probe, run_plan, run, refresh
+        self.state = "idle"
+        self.lines: deque = deque(maxlen=40)
+        self.task: asyncio.Task | None = None
+        self._refreshed = False
+        self._cache: tuple[float, tuple] | None = None  # the page asks every few seconds; a probe reads PATH's folders
+
+    def _plan(self) -> tuple[list[dict], list[dict]]:
+        if not self._refreshed:  # once: a tool an earlier install put on PATH must not read as missing
+            self._refreshed = True
+            try:
+                self._refresh()
+            except Exception:  # noqa: BLE001
+                pass
+        if self._cache and time.monotonic() - self._cache[0] < 15:
+            return self._cache[1]
+        report = self._probe()
+        missing = toolsetup.missing_tools(report)
+        plan = toolsetup.install_plan([t["id"] for t in missing], report.get("platform") or {}) if missing else []
+        self._cache = (time.monotonic(), (missing, plan))
+        return missing, plan
+
+    def status(self) -> dict:
+        try:
+            missing, plan = self._plan()
+        except Exception as e:  # noqa: BLE001 — a reading, never a failure of the page
+            return {"state": self.state, "error": f"could not check ({str(e)[:80]})", "missing": [], "lines": list(self.lines)}
+        runnable = [s for s in plan if s["kind"] in ("cmd", "release") and not s.get("admin")]
+        admin = next((s["argv"][2] for s in plan if s.get("admin")), "")
+        return {"state": self.state, "missing": [t["label"] for t in missing], "steps": [describe(s) for s in runnable],
+                "admin": admin, "installable": bool(runnable), "lines": list(self.lines)}
+
+    async def install(self) -> dict:
+        if self.task and not self.task.done():
+            return {"ok": True}
+        _missing, plan = self._plan()
+        steps = [s for s in plan if not s.get("admin")]
+        if not any(s["kind"] in ("cmd", "release") for s in steps):
+            return {"ok": False, "why": "nothing here can install them from this page"}
+        self.state, self._refreshed = "installing", False
+        self.lines.clear()
+        self.task = asyncio.ensure_future(asyncio.to_thread(self._install, steps))
+        return {"ok": True}
+
+    def _install(self, steps: list[dict]) -> None:
+        say = self.lines.append
+        try:
+            self._run_plan(steps, say=say, run=lambda argv: self._run(argv, say))
+            self._refresh()
+        except Exception as e:  # noqa: BLE001
+            say(f"   ✖ {str(e)[:160]}")
+        finally:
+            self._cache = None
+            self.state = "done"

{witbitz_code-1.5.0 → witbitz_code-1.6.0}/src/witbitz_code/uninstall.py

@@ -294,6 +294,7 @@ class Deps:
     remove_package: Callable[[dict], Any] = remove_package  # may be async: the CLI closes its network client first
     login_start: Callable[[], Any] = lambda: __import__("witbitz_code.wslstart", fromlist=["startup_here"]).startup_here()  # WSL only
     login_start_disable: Callable[[dict], bool] = lambda spec: __import__("witbitz_code.wslstart", fromlist=["startup_disable"]).startup_disable(spec)
+    menu_remove: Callable[[], bool] = lambda: __import__("witbitz_code.wslstart", fromlist=["menu_remove"]).menu_remove()  # WSL only
 
 
 async def run_uninstall(d: Deps) -> dict:
@@ -393,6 +394,8 @@ async def run_uninstall(d: Deps) -> dict:
     spec = d.login_start()  # WSL: the Windows Startup shortcut setup made (wslstart.py)
     if spec and d.login_start_disable(spec):
         d.say(f"✓ Removed the Windows Startup shortcut \"{spec['name'][:-4]}\" — it no longer starts when you log in")
+    if spec and d.menu_remove():
+        d.say(f"✓ Removed \"{spec['name'][:-4]}\" from the Start menu")
     d.remove_path(d.code_dir)
     d.say(f"✓ Deleted {d.code_dir}")
     pkg_gone = False

witbitz_code-1.6.0/src/witbitz_code/winbg.py

@@ -0,0 +1,97 @@
+"""Windows: witbitz-code's page manager (`witbitz-code ui`) runs in the BACKGROUND — no terminal window that stops it when
+closed (the owner, 2026-10-09: "currently it opens a terminal and it depends on it. can this be run in the background?").
+
+It runs under pythonw.exe, which has no console. Two things follow, both handled here at start:
+- stdout/stderr are None — what it says goes to a log file beside the pairings (ui.log, cut at 1 MB);
+- a console program it starts (OpenCode, netstat, tasklist, taskkill, winget …) would each open a NEW window — every child
+  is started with CREATE_NO_WINDOW instead (one patch of subprocess.Popen, which asyncio's Windows subprocesses use too; a
+  child of such a process inherits its windowless console, so OpenCode's own children stay hidden as well).
+Nothing here runs off Windows, or in a process that has a console (a `witbitz-code ui` typed into a terminal).
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+from collections.abc import Callable
+from pathlib import Path
+
+CREATE_NO_WINDOW = 0x08000000
+DETACHED_PROCESS = 0x00000008
+CREATE_NEW_PROCESS_GROUP = 0x00000200
+LOG_MAX = 1024 * 1024
+
+
+def has_console(platform: str | None = None) -> bool:
+    if (sys.platform if platform is None else platform) != "win32":
+        return True
+    try:
+        import ctypes  # noqa: PLC0415 — Windows only
+
+        return bool(ctypes.windll.kernel32.GetConsoleWindow())  # type: ignore[attr-defined]
+    except Exception:  # noqa: BLE001
+        return True
+
+
+def pythonw(executable: str | None = None) -> Path | None:
+    """pythonw.exe beside this Python (a uv tool's venv has both in Scripts), or None."""
+    p = Path(executable or sys.executable).with_name("pythonw.exe")
+    return p if p.exists() else None
+
+
+def quiet_children(popen: type = subprocess.Popen) -> bool:
+    """Every child from now on starts with CREATE_NO_WINDOW (unless it asked for a console or detachment itself)."""
+    if getattr(popen, "_witbitz_quiet", False):
+        return False
+    original = popen.__init__
+
+    def __init__(self, *args, **kwargs):  # noqa: ANN001, ANN002, ANN003
+        flags = kwargs.get("creationflags", 0) or 0
+        if not flags & (DETACHED_PROCESS | 0x00000010):  # 0x10 = CREATE_NEW_CONSOLE: the caller wants a window
+            kwargs["creationflags"] = flags | CREATE_NO_WINDOW
+        original(self, *args, **kwargs)
+
+    popen.__init__ = __init__
+    popen._witbitz_quiet = True
+    return True
+
+
+def log_to(path: Path) -> None:
+    """stdout/stderr → `path` (appended; started over past LOG_MAX), line-buffered so the page's tee sees each line."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    try:
+        if path.stat().st_size > LOG_MAX:
+            path.unlink()
+    except OSError:
+        pass
+    f = open(path, "a", encoding="utf-8", errors="replace", buffering=1)  # noqa: SIM115 — lives as long as the process
+    sys.stdout = f
+    sys.stderr = f
+
+
+def prepare(log_path: Path, *, platform: str | None = None, console: Callable[[], bool] | None = None) -> bool:
+    """In a windowless Windows process: log to a file and keep every child windowless. → whether it is in the background."""
+    if (sys.platform if platform is None else platform) != "win32":
+        return False
+    if (console or has_console)():
+        return False
+    if sys.stderr is None or sys.stdout is None:
+        log_to(log_path)
+    quiet_children()
+    return True
+
+
+def launch_ui(extra: list[str] | None = None, *, popen: Callable[..., object] = subprocess.Popen,
+              executable: str | None = None) -> tuple[bool, str]:
+    """Start `witbitz-code ui` in the background (pythonw, detached — closing this window does not stop it). → (ok, why)."""
+    w = pythonw(executable)
+    if not w:
+        return False, "pythonw.exe is not beside this Python"
+    try:
+        popen([str(w), "-m", "witbitz_code", "ui", *(extra or [])], cwd=os.path.expanduser("~"),
+              stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, close_fds=True,
+              creationflags=DETACHED_PROCESS | CREATE_NEW_PROCESS_GROUP)
+    except OSError as e:
+        return False, str(e)[:120]
+    return True, ""