witbitz-code 1.5.1__tar.gz → 1.6.1__tar.gz

{witbitz_code-1.5.1/src/witbitz_code.egg-info → witbitz_code-1.6.1}/PKG-INFO

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

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

{witbitz_code-1.5.1 → witbitz_code-1.6.1}/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.1 → witbitz_code-1.6.1}/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, uninstall, 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
 
@@ -123,9 +123,10 @@ class Manager:
                  login_enable: Callable[[dict], tuple] = wslstart.startup_enable,
                  login_disable: Callable[[dict], bool] = wslstart.startup_disable,
                  port_owners: Callable[[int], list] | None = None, stop_pid: Callable[[int], bool] | None = None,
-                 label: dict | None = None, log: deque | None = 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
@@ -143,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:
@@ -206,7 +209,8 @@ class Manager:
             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, "log": list(self.log)[-14:]}
+                "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
@@ -381,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()
@@ -518,6 +529,8 @@ class Server:
             "/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:
@@ -567,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.1 → witbitz_code-1.6.1}/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.1 → witbitz_code-1.6.1}/src/witbitz_code/ui_static/app.js

@@ -43,6 +43,7 @@ function elsewhereText(sv) {
 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
@@ -91,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')
 }
@@ -105,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.'
   }
 }
 
@@ -131,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.1 → witbitz_code-1.6.1}/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.1/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.1 → witbitz_code-1.6.1}/src/witbitz_code/uninstall.py

@@ -23,7 +23,7 @@ from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any
 
-from . import keys, plugins
+from . import keys, plugins, ports
 from . import pairings as pp
 from .wizard import find_opencode
 
@@ -138,6 +138,8 @@ def opencode_holders(data_dir: str) -> list[dict]:
                 cmd = ""
             hits.append({"pid": int(p), "cmd": cmd})
         return hits
+    if sys.platform == "win32":  # no /proc, no lsof: every opencode.exe of this user's (the owner, 2026-10-09: the background
+        return win_opencode_processes()  # copy's OpenCode held opencode.db and the delete died "WinError 32")
     files = [os.path.join(data_dir, f) for f in ("opencode.db", "opencode.db-wal", "opencode.db-shm") if os.path.exists(os.path.join(data_dir, f))]
     if not files or not shutil.which("lsof"):
         return hits
@@ -150,6 +152,55 @@ def opencode_holders(data_dir: str) -> list[dict]:
     return hits
 
 
+def win_opencode_processes(*, run: Callable[[list[str]], str] | None = None, user: str | None = None) -> list[dict]:
+    """Windows: this user's opencode.exe processes (tasklist, one CSV row each)."""
+    run = run or ports._run_text
+    user = os.environ.get("USERNAME", "") if user is None else user
+    hits = []
+    for line in run(["tasklist", "/V", "/FO", "CSV", "/NH", "/FI", "IMAGENAME eq opencode.exe"]).splitlines():
+        row = ports.parse_tasklist_row(line)
+        if row and (not user or row["user"].rsplit("\\", 1)[-1].lower() == user.lower()):
+            hits.append({"pid": row["pid"], "cmd": row["image"]})
+    return hits
+
+
+def running_witbitz(*, lock: Path | None = None, pairings: Callable[[], list] | None = None,
+                    owners: Callable[[int], list] | None = None, alive: Callable[[int], bool] | None = None) -> list[dict]:
+    """What runs witbitz-code here now: the page's manager (its ui.json names it — in the background it has no window to
+    close) and whatever holds each paired OpenCode port or its model proxy's (port + 100): a serve, its OpenCode."""
+    lock = lock or pp.pairings_path().parent / "ui.json"
+    pairings = pairings or (lambda: pp.load_pairings(log=lambda _m: None))
+    owners = owners or ports.port_owners
+    alive = alive or _alive
+    found: list[dict] = []
+    try:
+        pid = json.loads(lock.read_text(encoding="utf-8")).get("pid")
+        if isinstance(pid, int) and pid != os.getpid() and alive(pid):
+            found.append({"pid": pid, "cmd": "the Witbitz Code page"})
+    except (OSError, ValueError, AttributeError):
+        pass
+    for p in pairings():
+        tail = str(p.get("opencodeUrl") or "").rsplit(":", 1)[-1].rstrip("/")
+        port = int(tail) if tail.isdigit() else 0
+        for q in ([port, port + 100] if port else []):
+            for o in owners(q):
+                if o["pid"] != os.getpid() and all(o["pid"] != x["pid"] for x in found):
+                    found.append({"pid": int(o["pid"]), "cmd": str(o.get("cmd") or "")[:70]})
+    return found
+
+
+def _alive(pid: int) -> bool:
+    if sys.platform == "win32":
+        return _win_alive(pid)
+    try:
+        os.kill(pid, 0)
+        return True
+    except ProcessLookupError:
+        return False
+    except PermissionError:
+        return False  # another user's: not ours
+
+
 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
@@ -287,6 +338,7 @@ class Deps:
     sessions: Callable[[], dict] = None  # type: ignore[assignment]
     delete_sessions: Callable[[], None] = None  # type: ignore[assignment]
     opencode_processes: Callable[[], list] = lambda: opencode_holders(str(keys.auth_path().parent))
+    running: Callable[[], list] = running_witbitz
     stop_process: Callable[[int], bool] = stop_process
     opencode: Callable[[], dict] = opencode_here
     remove_opencode_program: Callable[[dict], dict] = remove_opencode_program
@@ -294,6 +346,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:
@@ -331,6 +384,12 @@ async def run_uninstall(d: Deps) -> dict:
     how = {"installer": "from OpenCode's installer, in ~/.opencode", "npm": "with npm", "brew": "with Homebrew"}.get(oc["kind"])
     remove_oc = ask(d.remove_opencode, f"Also remove OpenCode itself (installed {how})? [y/N] ") if oc["kind"] not in ("none", "other") else False
 
+    # The running witbitz-code first — the page's manager in the background, a serve, their OpenCode: it holds the files
+    # about to go (Windows refuses to delete an open file) and would keep answering the phone. Continue already said yes.
+    for p in d.running():
+        d.say(f"✓ Stopped the running witbitz-code: {p['cmd'] or 'a program'} (process {p['pid']})" if d.stop_process(p["pid"])
+              else f"✖ Could not stop {p['cmd'] or 'a program'} (process {p['pid']}) — close it, then run uninstall again")
+
     # Sessions: an OpenCode that has its database open would write it back — never delete under it.
     while remove_sessions:
         procs = d.opencode_processes()
@@ -375,8 +434,11 @@ async def run_uninstall(d: Deps) -> dict:
         d.remove_path(notes["root"])
         d.say(f"✓ Deleted {notes['root']}")
     if remove_sessions:
-        d.delete_sessions()
-        d.say(f"✓ Deleted the OpenCode sessions in {sessions['dir']} (provider logins kept)")
+        stuck = d.delete_sessions() or []
+        if stuck:
+            d.say(f"✖ Could not delete {', '.join(stuck[:4])} in {sessions['dir']} — another program still has it open; close OpenCode and delete it yourself")
+        else:
+            d.say(f"✓ Deleted the OpenCode sessions in {sessions['dir']} (provider logins kept)")
     oc_gone = False
     if remove_oc:
         try:
@@ -393,6 +455,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
@@ -451,12 +515,18 @@ def sessions_info() -> dict:
     return {"dir": str(d), "exists": exists}
 
 
-def delete_sessions() -> None:
+def delete_sessions() -> list[str]:
+    """→ the names that could not be deleted (Windows: a file another program still has open), never a crash."""
     d = keys.auth_path().parent
+    left = []
     for f in d.iterdir():
         if f.name == "auth.json":
             continue
-        shutil.rmtree(f, ignore_errors=True) if f.is_dir() and not f.is_symlink() else f.unlink(missing_ok=True)
+        try:
+            shutil.rmtree(f, ignore_errors=True) if f.is_dir() and not f.is_symlink() else f.unlink(missing_ok=True)
+        except OSError:
+            left.append(f.name)
+    return left
 
 
 def saved_keys() -> list[str]:

witbitz_code-1.6.1/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, ""