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

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

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

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

{witbitz_code-1.5.0 → witbitz_code-1.5.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, wizard, wslstart
+from . import __version__, devicelink, link, net, ports, qr, uninstall, 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,13 @@ 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,
+                 port_owners: Callable[[int], list] | None = None, stop_pid: Callable[[int], bool] | 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._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)
@@ -196,15 +200,66 @@ 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,
+        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, "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 +271,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 +280,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:
@@ -455,7 +513,7 @@ 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 "")),

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

@@ -31,6 +31,13 @@ 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) {
@@ -43,7 +50,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 +65,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)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: witbitz-code
-Version: 1.5.0
+Version: 1.5.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.0 → witbitz_code-1.5.1}/tests/test_ui.py

@@ -192,3 +192,54 @@ def test_the_page_names_which_computer_it_controls(monkeypatch):
     monkeypatch.setattr(ui.sys, "platform", "linux")
     monkeypatch.setenv("WSL_DISTRO_NAME", "UbuntuD")
     assert ui.computer_label() == {"label": "UbuntuD (WSL) on AlonASUS", "kind": "WSL UbuntuD"}
+
+
+def _other_window_manager(w, held):
+    """A manager on a computer where setup's window already serves port 4097 (+ the proxy's 4197), as the owner's laptop did."""
+    stopped = []
+
+    async def is_listening(p):
+        return p in held
+
+    def stop_pid(pid):
+        stopped.append(pid)
+        held.clear()
+        return True
+
+    m = ui.Manager(serve=w.serve, is_listening=is_listening, pair=w.pair, load_pairings=lambda: list(w.pairings),
+                   port_owners=lambda q: [{"pid": 19824, "cmd": "python.exe"}] if q in held else [],
+                   stop_pid=stop_pid, login_spec=lambda: None, label={"label": "AlonASUS", "kind": "Windows"}, log=deque(maxlen=60))
+    return m, stopped
+
+
+def test_a_copy_serving_in_another_window_is_shown_and_run_it_here_takes_over():
+    async def go():
+        w = World([DESK])
+        m, stopped = _other_window_manager(w, {4097, 4197})
+        assert (await m.status())["serving"] == {"state": "elsewhere", "port": 4097, "owners": [{"pid": 19824, "cmd": "python.exe"}]}
+        r = await m.start_serving()  # the launch's own start: leaves setup's window alone, starts nothing
+        assert r["ok"] is False and stopped == [] and w.serves == []
+        srv, base = await with_server(m)
+        try:
+            async with httpx.AsyncClient() as c:
+                assert (await c.post(f"{base}/api/serve", headers=authed(srv), json={"on": True})).json() == {"ok": True}
+                assert stopped == [19824], "Run it here stops the other copy first"
+                async def served():
+                    return w.serves == [["--port", "4097"]]
+                await until(served)
+                assert (await m.status())["serving"]["state"] == "online"
+        finally:
+            await m.shutdown()
+            await srv.close()
+    run(go())
+
+
+def test_stop_stops_a_copy_running_in_another_window():
+    async def go():
+        w = World([DESK])
+        m, stopped = _other_window_manager(w, {4197})
+        r = await m.stop_serving()
+        assert r["ok"] is True and stopped == [19824] and "process 19824" in r["said"][0]
+        assert (await m.status())["serving"]["state"] == "stopped"
+        assert w.serves == []
+    run(go())