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

{witbitz_code-1.5.1/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.1
+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.1 → witbitz_code-1.6.0}/pyproject.toml

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

{witbitz_code-1.5.1 → 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.1 → 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, 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.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.1 → witbitz_code-1.6.0}/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.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.1 → 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, ""

{witbitz_code-1.5.1 → witbitz_code-1.6.0}/src/witbitz_code/wizard.py

@@ -90,6 +90,8 @@ class Deps:
     run_tools: Callable[[list], dict] = None  # type: ignore[assignment]
     refresh_path: Callable[[], None] = lambda: None
     serve_here: Callable[[int], Awaitable[int]] = None  # type: ignore[assignment]
+    # Windows: start the page's manager in the background (winbg.launch_ui) instead of serving in this window → (ok, why)
+    background_ui: Callable[[], tuple] | None = None
     result: dict = field(default_factory=lambda: {"opencode": False, "paired": False, "keys": False, "running": ""})
 
 
@@ -120,6 +122,19 @@ async def run_setup(d: Deps) -> dict:
     d.say("   ✓ OpenCode is installed")
     result["opencode"] = True
 
+    # Windows and WSL: the rest — pairing, the tools, start when I log in — is on a page in the browser, and witbitz-code
+    # runs in the background (no window to keep open). The owner, 2026-10-09: "the installer still asks its questions in
+    # the terminal - why the terminal?" → "in wsl, will we get the same page install by default when we setup?". --here:
+    # the steps below, in this terminal, as before.
+    if d.background_ui:
+        ok, why = d.background_ui()
+        if ok:
+            d.say("\n2. The rest is on a page in your browser — it is opening now: pair this computer there, and install the tools.")
+            d.say("   witbitz-code runs in the background; you can close this window. The page's Quit stops it.")
+            d.say("   To open the page again: witbitz-code ui" + ("" if d.wsl else "   (or Start menu → Witbitz Code)") + "\n")
+            return {**result, "running": "background"}
+        d.say(f"   (Could not start it in the background: {why} — carrying on here)")
+
     # 2 — pairing (a pairing belongs to one OpenCode port; already paired for another port → use it, or move it on --port)
     d.say("\n2. This computer and your Witbitz account")
     on = lambda lst, p: [x for x in lst if d.port_of(x) == p]  # noqa: E731

{witbitz_code-1.5.1 → witbitz_code-1.6.0}/src/witbitz_code/wslstart.py

@@ -4,10 +4,13 @@ have the option to start on login?" → "can it be automatic in the install?"),
 WSL runs only once something on Windows starts it, so the start lives on the WINDOWS side: a shortcut in the Windows Startup
 folder that runs
 
-    wsl.exe -d <distro> -u <user> --cd ~ -- <this witbitz-code> ui --no-browser
+    conhost.exe --headless wsl.exe -d <distro> -u <user> --cd ~ -- <this witbitz-code> ui --no-browser
 
-in a minimized window: the page's manager, serving, without opening a browser. That window keeps WSL running; closing it
-stops witbitz-code. Native Windows: the installer's own Startup shortcut "Witbitz Code.lnk" (code.ps1), pointed at its
+with NO window (1.6.0; the owner, 2026-10-09: "can this be run in the background?"): the page's manager, serving, without
+opening a browser. The wsl.exe it holds keeps WSL running (WSL shuts down soon after its last Windows-side process ends,
+background programs included); the page's Quit ends it. setup hands off the same way, opening the page (launch_background).
+Measured on the owner's laptop: conhost --headless runs wsl.exe with MainWindowHandle 0, and the command runs in the distro.
+(1.4.0–1.5.x wrote a minimized wsl.exe window instead.) Native Windows: the installer's own Startup shortcut "Witbitz Code.lnk" (code.ps1), pointed at its
 launcher. Written and removed by Windows PowerShell (WSL's interop reaches it). = tools/code-wsl-start.mjs (held equal by test).
 """
 
@@ -25,8 +28,11 @@ from . import ports
 
 POWERSHELL = "/mnt/c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe"
 STARTUP = "[Environment]::GetFolderPath('Startup')"
+PROGRAMS = "[Environment]::GetFolderPath('Programs')"  # the Start menu
 WSL_EXE = "(Join-Path $env:WINDIR 'System32\\wsl.exe')"
-UI_QUIET = ["ui", "--no-browser"]  # what a login start runs: the page's manager, serving, no browser (ui.py)
+CONHOST = "(Join-Path $env:WINDIR 'System32\\conhost.exe')"
+UI_QUIET = ["ui", "--no-browser", "--hidden"]  # what a WSL login start runs: the page's manager, serving, no browser, no window (ui.py)
+WIN_QUIET = ["ui", "--no-browser"]  # native Windows: pythonw knows it has no window by itself (winbg.py)
 
 
 def shortcut_name(distro: str) -> str:
@@ -44,6 +50,11 @@ def wsl_args(distro: str, user: str, cmd: list[str], verb: list[str] | None = No
     return _join(parts)
 
 
+def headless_args(distro: str, user: str, cmd: list[str], verb: list[str]) -> str:
+    """conhost.exe's arguments: no window, then wsl.exe with wsl_args."""
+    return "--headless wsl.exe " + wsl_args(distro, user, cmd, verb)
+
+
 def _q(s: str) -> str:  # a PowerShell single-quoted string
     return "'" + s.replace("'", "''") + "'"
 
@@ -94,19 +105,55 @@ def startup_here() -> dict | None:
     if not exe:
         return None
     distro = os.environ.get("WSL_DISTRO_NAME", "")
-    return {"name": shortcut_name(distro), "args": wsl_args(distro, getpass.getuser(), [exe], UI_QUIET), "target": WSL_EXE}
+    return {"name": shortcut_name(distro), "args": headless_args(distro, getpass.getuser(), [exe], UI_QUIET), "target": CONHOST}
+
+
+def menu_name(distro: str) -> str:
+    """The WSL copy's own Start-menu entry — Windows lists it apart from the Windows copy's "Witbitz Code" (the owner,
+    2026-10-09: "the windows witbitz code program for wsl should be called differently")."""
+    return shortcut_name(distro)
+
+
+def launch_script(args: str) -> str:
+    return (f"Start-Process -FilePath {CONHOST} -ArgumentList {_q(args)} -WorkingDirectory $env:USERPROFILE; 'ok'")
+
+
+def launch_background(*, ps: Callable[[str], tuple[int, str]] = run_ps, which: Callable[[str], str | None] = shutil.which,
+                      on_wsl: Callable[[], bool] = ports.on_wsl) -> tuple[bool, str]:
+    """WSL: start the page's manager with no window, held by a hidden wsl.exe on the Windows side, and let it open the
+    page in the Windows browser — setup's hand-off (this terminal may then close). → (ok, why)."""
+    if not on_wsl():
+        return False, "not in WSL"
+    exe = which("witbitz-code")
+    if not exe:
+        return False, "witbitz-code is not on PATH"
+    distro = os.environ.get("WSL_DISTRO_NAME", "")
+    args = headless_args(distro, getpass.getuser(), [exe], ["ui", "--hidden"])
+    # The Start-menu entry first (it opens this page again, starting it if it is not running), then the start itself.
+    menu = enable_script(menu_name(distro), args, folder=PROGRAMS, target=CONHOST)
+    # A login start written by 1.4.0–1.5.x opens a minimized window: an existing one is rewritten to start hidden too.
+    quiet = headless_args(distro, getpass.getuser(), [exe], UI_QUIET)
+    login = (f"if (Test-Path (Join-Path ({STARTUP}) {_q(shortcut_name(distro))})) {{ "
+             f"{enable_script(shortcut_name(distro), quiet, target=CONHOST)} | Out-Null }}")
+    code, out = ps(f"try {{ {menu} | Out-Null; {login} }} catch {{ }}; {launch_script(args)}")
+    ok = code == 0 and bool(out) and out.splitlines()[-1].strip() == "ok"
+    return ok, "" if ok else ("Windows PowerShell could not be started" if code == -1 else f"Windows PowerShell answered {code}")
 
 
 def windows_startup_spec(env: dict | None = None, which: Callable[[str], str | None] = shutil.which,
-                         exists: Callable[[str], bool] = os.path.exists) -> dict | None:
-    """Native Windows: the installer's own Startup shortcut "Witbitz Code.lnk", pointed at its launcher (which passes its
-    arguments on to `witbitz-code ui`), or — installed without it (pipx) — at witbitz-code itself."""
+                         exists: Callable[[str], bool] = os.path.exists, executable: str | None = None) -> dict | None:
+    """Native Windows: the installer's own Startup shortcut "Witbitz Code.lnk". It runs the page's manager in the
+    background — pythonw.exe beside this Python, no window (winbg.py) — or, without pythonw, the installer's launcher
+    (which passes its arguments on to `witbitz-code ui`), or — installed without it (pipx) — witbitz-code itself."""
     env = os.environ if env is None else env
+    pyw = os.path.join(os.path.dirname(executable or sys.executable), "pythonw.exe")
+    if exists(pyw):
+        return {"name": "Witbitz Code.lnk", "args": _join(["-m", "witbitz_code", *WIN_QUIET]), "target": _q(pyw)}
     launcher = os.path.join(env.get("LOCALAPPDATA", ""), "Witbitz", "Witbitz Code.cmd")
     if env.get("LOCALAPPDATA") and exists(launcher):
         return {"name": "Witbitz Code.lnk", "args": "--no-browser", "target": _q(launcher)}
     exe = which("witbitz-code")
-    return {"name": "Witbitz Code.lnk", "args": _join(UI_QUIET), "target": _q(exe)} if exe else None
+    return {"name": "Witbitz Code.lnk", "args": _join(WIN_QUIET), "target": _q(exe)} if exe else None
 
 
 def login_spec() -> dict | None:
@@ -129,6 +176,12 @@ def startup_enable(spec: dict, *, ps: Callable[[str], tuple[int, str]] = run_ps)
     return ok, "" if ok else (f"Windows PowerShell answered {code}" if code != -1 else "Windows PowerShell could not be started")
 
 
+def menu_remove(*, ps: Callable[[str], tuple[int, str]] = run_ps) -> bool:
+    """WSL: remove this distro's Start-menu entry (uninstall). True when one was there and is gone."""
+    code, out = ps(disable_script(menu_name(os.environ.get("WSL_DISTRO_NAME", "")), folder=PROGRAMS))
+    return code == 0 and bool(out) and out.splitlines()[-1].strip() == "removed"
+
+
 def startup_disable(spec: dict, *, ps: Callable[[str], tuple[int, str]] = run_ps) -> bool:
     """True when a shortcut was there and is gone."""
     code, out = ps(disable_script(spec["name"]))