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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: witbitz-code
-Version: 1.3.8
+Version: 1.5.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
@@ -56,6 +56,13 @@ Poppler, Tesseract, … — with winget, Homebrew or one `sudo apt-get` line; it
 starts `serve` in the window. Then open Code in Spaces. Leave it running (Ctrl-C
 stops it); next time, `witbitz-code serve` is enough.
 
+**Or in your browser:** `witbitz-code ui` (on Windows: Start menu → Witbitz Code) opens a page for this computer — whether
+it is online, which account it is paired with and this month's spend, Pair (the code is shown large on the page), Unpair,
+Pair again, Start / Stop, and Start when I log in (Windows and WSL). It serves while its window is open; closing that window
+stops it, and `witbitz-code ui` again just opens the page. Each copy has its own page — on one laptop Windows and WSL each
+get theirs, titled with the computer it controls. The page answers only this computer, and only the browser the link
+opened (a one-time key traded for a private cookie; no other website can drive it).
+
 **No key to paste.** Pairing asks your Spaces account for this computer's own TrustedRouter and Tinfoil keys, capped by the
 providers (today up to $50 of models and $5 of tools a month per computer). They are sent sealed to this computer, kept in
 `~/.witbitz/code/account-keys.json` (0600) and never given to OpenCode: the local proxy puts them on each call. Model calls
@@ -77,6 +84,7 @@ The same thing one step at a time: install OpenCode (`curl -fsSL https://opencod
 
 | command | what it does |
 |---|---|
+| `ui [--no-browser]` | The page above. `--no-browser` serves without opening it (what a login start runs). |
 | `setup [--port <n>]` | The walk-through above. With `--port`, a pairing made for another port moves to it (no new scan). |
 | `uninstall [--yes] [--remove-keys] [--remove-notes] [--remove-sessions] [--remove-opencode]` | Remove witbitz-code from this computer: its coding keys go back to each account, each account lets go of it, `~/.witbitz/code` and what `serve` added to OpenCode are deleted, and the pipx install removes itself. Asks first (Enter keeps) before your saved keys, project notes, OpenCode's sessions and OpenCode itself; never deletes sessions an OpenCode still has open. `--yes` skips the questions and keeps all four unless their flag is given. |
 | `pair [--name <name>] [--port <n> \| --opencode-url <url>]` | Show the QR code. The account that scans it gets this computer. `--name` sets the label your devices show (default: the hostname). |
@@ -90,7 +98,14 @@ The same thing one step at a time: install OpenCode (`curl -fsSL https://opencod
 
 **Windows and WSL on one computer** are two computers to Spaces, and both can run: WSL shares Windows' ports, so the second
 one `setup` meets gets its own (it asks — 4097, and 4197 for its model proxy) and `serve` remembers it. WSL's is named
-"<computer> (WSL)"; one paired before 1.3.8 is renamed by its next `setup`.
+"<computer> (WSL)"; one paired before 1.3.8 is renamed by its next `setup`. In WSL, `setup` also offers to start witbitz-code
+when you log in to Windows (WSL runs only once Windows starts it): a shortcut in the Windows Startup folder opens a minimized
+window running it (`ui --no-browser`: serving, the page there when you want it) — closing that window stops it, and
+`witbitz-code uninstall` removes the shortcut.
+
+**Any folder, any drive.** New session in Code opens at your home folder; ‹ Up goes past it (on Windows up to "This
+computer", which lists the drives), and a folder can be typed (`D:\projects`). witbitz-code lists the folder names itself
+— nothing else of the computer — and "New folder" makes one where you are. A cloud computer keeps to its workspace.
 
 **More than one account.** Each account that scans the QR code gets its own pairing, with its own secret and relay
 channel. OpenCode has no users, so every paired account reaches the same sessions, files and shell. That's fine when

{witbitz_code-1.3.8 → witbitz_code-1.5.0}/README.md

@@ -30,6 +30,13 @@ Poppler, Tesseract, … — with winget, Homebrew or one `sudo apt-get` line; it
 starts `serve` in the window. Then open Code in Spaces. Leave it running (Ctrl-C
 stops it); next time, `witbitz-code serve` is enough.
 
+**Or in your browser:** `witbitz-code ui` (on Windows: Start menu → Witbitz Code) opens a page for this computer — whether
+it is online, which account it is paired with and this month's spend, Pair (the code is shown large on the page), Unpair,
+Pair again, Start / Stop, and Start when I log in (Windows and WSL). It serves while its window is open; closing that window
+stops it, and `witbitz-code ui` again just opens the page. Each copy has its own page — on one laptop Windows and WSL each
+get theirs, titled with the computer it controls. The page answers only this computer, and only the browser the link
+opened (a one-time key traded for a private cookie; no other website can drive it).
+
 **No key to paste.** Pairing asks your Spaces account for this computer's own TrustedRouter and Tinfoil keys, capped by the
 providers (today up to $50 of models and $5 of tools a month per computer). They are sent sealed to this computer, kept in
 `~/.witbitz/code/account-keys.json` (0600) and never given to OpenCode: the local proxy puts them on each call. Model calls
@@ -51,6 +58,7 @@ The same thing one step at a time: install OpenCode (`curl -fsSL https://opencod
 
 | command | what it does |
 |---|---|
+| `ui [--no-browser]` | The page above. `--no-browser` serves without opening it (what a login start runs). |
 | `setup [--port <n>]` | The walk-through above. With `--port`, a pairing made for another port moves to it (no new scan). |
 | `uninstall [--yes] [--remove-keys] [--remove-notes] [--remove-sessions] [--remove-opencode]` | Remove witbitz-code from this computer: its coding keys go back to each account, each account lets go of it, `~/.witbitz/code` and what `serve` added to OpenCode are deleted, and the pipx install removes itself. Asks first (Enter keeps) before your saved keys, project notes, OpenCode's sessions and OpenCode itself; never deletes sessions an OpenCode still has open. `--yes` skips the questions and keeps all four unless their flag is given. |
 | `pair [--name <name>] [--port <n> \| --opencode-url <url>]` | Show the QR code. The account that scans it gets this computer. `--name` sets the label your devices show (default: the hostname). |
@@ -64,7 +72,14 @@ The same thing one step at a time: install OpenCode (`curl -fsSL https://opencod
 
 **Windows and WSL on one computer** are two computers to Spaces, and both can run: WSL shares Windows' ports, so the second
 one `setup` meets gets its own (it asks — 4097, and 4197 for its model proxy) and `serve` remembers it. WSL's is named
-"<computer> (WSL)"; one paired before 1.3.8 is renamed by its next `setup`.
+"<computer> (WSL)"; one paired before 1.3.8 is renamed by its next `setup`. In WSL, `setup` also offers to start witbitz-code
+when you log in to Windows (WSL runs only once Windows starts it): a shortcut in the Windows Startup folder opens a minimized
+window running it (`ui --no-browser`: serving, the page there when you want it) — closing that window stops it, and
+`witbitz-code uninstall` removes the shortcut.
+
+**Any folder, any drive.** New session in Code opens at your home folder; ‹ Up goes past it (on Windows up to "This
+computer", which lists the drives), and a folder can be typed (`D:\projects`). witbitz-code lists the folder names itself
+— nothing else of the computer — and "New folder" makes one where you are. A cloud computer keeps to its workspace.
 
 **More than one account.** Each account that scans the QR code gets its own pairing, with its own secret and relay
 channel. OpenCode has no users, so every paired account reaches the same sessions, files and shell. That's fine when

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "witbitz-code"
-version = "1.3.8"
+version = "1.5.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"
@@ -43,7 +43,7 @@ where = ["src"]
 
 # Our OpenCode plugins, installed by `serve` (plugins.py) — copies of tools/opencode-plugins, kept current by embed.mjs
 [tool.setuptools.package-data]
-witbitz_code = ["opencode_plugins/*", "confidential_models.json", "offered_models.json", "tools_catalog.json"]
+witbitz_code = ["opencode_plugins/*", "confidential_models.json", "offered_models.json", "tools_catalog.json", "ui_static/*"]
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]

{witbitz_code-1.3.8 → witbitz_code-1.5.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.3.8"
+__version__ = "1.5.0"

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

@@ -35,6 +35,8 @@ HELP = f"""witbitz-code {__version__} — reach OpenCode on this computer from t
 
   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
   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
@@ -149,7 +151,9 @@ async def _stop_opencode(child: asyncio.subprocess.Process) -> None:
         await child.wait()
 
 
-async def serve(args: list[str]) -> int:
+async def serve(args: list[str], *, stop: Any = None, live_out: dict | None = None) -> int:
+    """`stop` and `live_out`: the page's manager (ui.py) runs serve inside itself — it stops it with its own flag instead
+    of a signal, and reads the running connector (each pairing's relay state) from live_out."""
     port_n = to_number(_flag(args, "--port", "4096"))
     port = int(port_n) if truthy(port_n) and port_n == port_n and float(port_n).is_integer() else 4096
     everything = pp.load_pairings(log=lambda _m: None)
@@ -207,7 +211,7 @@ async def serve(args: list[str]) -> int:
         # Billed to the account whose prompt started the turn (payers.py); a call nobody here started is refused.
         return live_keys.credential(payers.payer(req.header("x-session-id")[:100], req.header("x-parent-session-id")[:100]))
 
-    stop = _Stop()
+    stop = stop or _Stop()
     child = None
     proxy = None
     live: dict = {"connector": None}
@@ -257,6 +261,8 @@ async def serve(args: list[str]) -> int:
         connector = await start_connector(pairings, payers=payers)
         live["status"] = asyncio.ensure_future(_check_keys_every(live_keys, keys_http))
         live["connector"] = connector
+        if live_out is not None:
+            live_out["connector"] = connector
         if proxy:
             connector.set_confidential_sink(proxy.add_confidential)  # the page hands down what the account offers today
         served = ", ".join(f'"{p.get("name")}" → {p.get("account") or "account"}' for p in pairings)
@@ -265,6 +271,8 @@ async def serve(args: list[str]) -> int:
             return await _wait_for_stop(stop, child)
         finally:
             live["status"].cancel()
+            if live_out is not None:
+                live_out.pop("connector", None)
             await connector.aclose()
     finally:
         if child is not None:
@@ -379,6 +387,19 @@ async def uninstall(args: list[str]) -> int:
     return 0 if r.get("done") else 1
 
 
+async def ui_command(args: list[str]) -> int:
+    """This computer's witbitz-code in a page in your browser (ui.py): status, pair / unpair / pair again, start and stop,
+    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
+
+    http = net.new_client()
+    keys = pair_cmd._KeyCalls(http)
+    try:
+        return await ui.run(args, serve=serve, is_listening=is_listening, keys_line=lambda p: pair_cmd._keys_line(p, keys))
+    finally:
+        await http.aclose()
+
+
 async def _main(argv: list[str]) -> int:
     cmd, rest = (argv[0], argv[1:]) if argv else ("", [])
     if cmd == "uninstall":
@@ -392,6 +413,8 @@ async def _main(argv: list[str]) -> int:
         return await pair_cmd.main(rest)
     if cmd == "serve":
         return await serve(rest)
+    if cmd == "ui":
+        return await ui_command(rest)
     if cmd == "status":
         return await pair_cmd.main(["--status"])
     if cmd == "rotate":

{witbitz_code-1.3.8 → witbitz_code-1.5.0}/src/witbitz_code/connector.py

@@ -40,6 +40,8 @@ from .outputs import OUTPUT_ROUTE, serve_output
 from .plugins import notes_plugin_path as default_notes_plugin, notes_root as default_notes_root, notes_rules
 from .payers import SessionPayers
 from .seen import SEEN_ROUTE, merge_seen, norm_seen
+from .dirs import DIRS_ROUTE, list_dirs
+from .mkdir import MKDIR_ROUTE, mkdir_in
 from .pairings import DEFAULT_OPENCODE_URL, hostname, read_env_password
 from .relay import RELAY_URL, Connect, RelayPeer, allowed_event_path, allowed_request, project_response
 from .tools_probe import probe_tools
@@ -192,6 +194,7 @@ class PairingServer:
         #   and run again. Each socket therefore announces a fresh random nonce inside its sealed hello, and a request
         #   must carry the CURRENT one: a recording from before a restart or reconnect carries a nonce nobody accepts.
         self.nonce = ""
+        self.relay_state = "connecting"  # the relay socket's last state — the page (ui.py) shows "online" when every one is open
         self.peer = RelayPeer(secret=pairing["secret"], role="computer", relay=pairing.get("relay") or RELAY_URL,
                               on_state=self._on_state, on_peers=self._on_peers, on_message=self._on_message, connect=connect,
                               # A page socket fell out of the replay window: its recorded frames would open again — rotate the
@@ -248,6 +251,7 @@ class PairingServer:
 
     # ── relay events ──────────────────────────────────────────────────────────────────────────────────────────────────
     def _on_state(self, s: str) -> None:
+        self.relay_state = s
         self._log(f"witbitz-code: {self.name} · relay {s}")
         if s == "open":
             self._rotate()
@@ -396,6 +400,29 @@ class PairingServer:
                                        log=lambda line: self._log(f"opencode-connector: {self.name} · {line}"))
             await reply(st, b)
             return
+        # "BROWSE THIS COMPUTER" (dirs.py): folder NAMES anywhere on this computer — above ~ and other drives — for the
+        # New-session picker. Answered HERE, never forwarded; less than the agent's shell already sees.
+        if bare == DIRS_ROUTE and m.get("m") == "GET":
+            q = dict(urllib.parse.parse_qsl(query, keep_blank_values=True))
+            st, b = list_dirs(path=q.get("path", ""))
+            await reply(st, b)
+            return
+        # "NEW FOLDER" (mkdir.py = tools/code-mkdir.mjs): one clean leaf under the folder the picker shows. Answered HERE.
+        if bare == MKDIR_ROUTE and m.get("m") == "POST":
+            q = dict(urllib.parse.parse_qsl(query, keep_blank_values=True))
+            if not q.get("directory"):
+                await reply(400, {"error": "no home to create under"})
+                return
+            try:
+                parsed = json.loads(m.get("b") or "null")
+            except ValueError:
+                parsed = None
+            if not isinstance(parsed, dict) or not isinstance(parsed.get("name"), str):
+                await reply(400, {"error": "no folder name"})
+                return
+            st, b = mkdir_in(root=q["directory"], rel=q.get("path"), name=parsed["name"])
+            await reply(st, b)
+            return
         if not allowed_request(m.get("m"), m.get("p")):
             await reply(403, {"error": "not allowed by the connector"})
             return

witbitz_code-1.5.0/src/witbitz_code/dirs.py

@@ -0,0 +1,108 @@
+"""Which folders are in <path> — the New-session picker's "browse this computer" (= tools/code-dirs.mjs; the page side is
+spaces/public/codeDirs.js). GET /witbitz/dirs?path=<absolute folder> → {path, parent, dirs: [{name, path}]}; no path = the
+top: on Windows the drives (path '', each drive a folder), elsewhere '/'. Folder NAMES only, answered by the connector and
+never forwarded to OpenCode (its listing refuses anything above the folder it was asked about) — the owner, 2026-10-09:
+"How can I reach other directories? Or drives (like D:)".
+
+Left out: a name starting with "." or "$", and a link/junction that cannot be listed (Windows keeps legacy junctions like
+"Application Data" that deny listing). parent: the folder above; at a drive's root '' (= the drives); at / None.
+"""
+
+from __future__ import annotations
+
+import json
+import ntpath
+import os
+import posixpath
+import re
+import sys
+from typing import Callable
+
+DIRS_ROUTE = "/witbitz/dirs"
+MAX_DIRS = 2000
+_WIN_ABS = re.compile(r"^[A-Za-z]:[\\/]")
+_SKIP = {"System Volume Information"}
+
+Entry = tuple  # (name, is_dir, is_link)
+
+
+def _json(o: object) -> str:
+    return json.dumps(o, ensure_ascii=False, separators=(",", ":"))
+
+
+def _error(st: int, message: str) -> tuple[int, str]:
+    return st, _json({"error": message})
+
+
+def _scandir(p: str) -> list[Entry]:
+    out = []
+    with os.scandir(p) as it:
+        for e in it:
+            link = e.is_symlink() or bool(getattr(e, "is_junction", lambda: False)())
+            try:
+                d = e.is_dir(follow_symlinks=False)
+            except OSError:
+                d = False
+            out.append((e.name, d, link))
+    return out
+
+
+def win_drives(exists: Callable[[str], bool] = os.path.exists) -> list[str]:
+    """The drive letters with a root folder here (C:, D:, …)."""
+    out = []
+    for c in range(65, 91):
+        d = chr(c) + ":"
+        try:
+            if exists(d + "\\"):
+                out.append(d)
+        except OSError:
+            pass
+    return out
+
+
+def _listable(readdir: Callable[[str], list], p: str) -> bool:
+    try:
+        readdir(p)
+        return True
+    except OSError:
+        return False
+
+
+def list_dirs(*, path: str = "", platform: str | None = None, readdir: Callable[[str], list[Entry]] = _scandir,
+              is_dir: Callable[[str], bool] = os.path.isdir, drives: Callable[[], list[str]] = win_drives) -> tuple[int, str]:
+    """The folders in `path` (absolute; '' = the top) → (status, JSON body)."""
+    win = (sys.platform if platform is None else platform) == "win32"
+    P = ntpath if win else posixpath
+    p = path if isinstance(path, str) else ""
+    if not p:
+        if win:
+            return 200, _json({"path": "", "parent": None, "dirs": [{"name": d, "path": d + "\\"} for d in drives()]})
+        p = "/"
+    if len(p) > 4096 or "\0" in p or not (_WIN_ABS.match(p) if win else p.startswith("/")):
+        return _error(400, "not a full folder path")
+    abs_ = P.normpath(p)
+    drive, _ = P.splitdrive(abs_)
+    root = (drive + "\\") if win else "/"
+    if win and abs_ == drive:
+        abs_ = root
+    try:
+        entries = readdir(abs_)
+    except (FileNotFoundError, NotADirectoryError):
+        return _error(404, "no such folder on this computer")
+    except PermissionError:
+        return _error(403, "this computer does not let you open that folder")
+    except OSError as e:
+        return _error(500, f"could not list it ({str(e)[:120]})")
+    dirs = []
+    for name, d, link in entries:
+        name = str(name or "")
+        if not name or name.startswith(".") or name.startswith("$") or name in _SKIP:
+            continue
+        full = P.join(abs_, name)
+        if (is_dir(full) and _listable(readdir, full)) if link else d:
+            dirs.append({"name": name, "path": full})
+        if len(dirs) >= MAX_DIRS:
+            break
+    dirs.sort(key=lambda x: (x["name"].lower(), x["name"]))
+    parent = ("" if win else None) if abs_ == root else P.dirname(abs_)
+    return 200, _json({"path": abs_, "parent": parent, "dirs": dirs})

witbitz_code-1.5.0/src/witbitz_code/mkdir.py

@@ -0,0 +1,55 @@
+""""New folder" in the New-session picker — tools/code-mkdir.mjs in Python (the page side is spaces/public/codeMkdir.js).
+POST /witbitz/mkdir?directory=<root>&path=<rel> {name} creates ONE clean leaf under root/rel, answered by the connector and
+never forwarded to OpenCode. Until 1.3.9 the Python connector had no such route, so the button failed on every pipx install.
+Checks, in this order: one clean leaf name; the target's parent's REAL path is inside the root's (a link cannot smuggle the
+write out); mkdir 0700, refused if it already exists. Windows roots (C:\\Users\\…) work as POSIX ones do.
+"""
+
+from __future__ import annotations
+
+import json
+import ntpath
+import os
+import posixpath
+import re
+
+MKDIR_ROUTE = "/witbitz/mkdir"
+_CLEAN = re.compile(r"^[A-Za-z0-9_ ()-][A-Za-z0-9._ ()-]*$")
+_WIN_ABS = re.compile(r"^[A-Za-z]:[\\/]")
+
+
+def _error(st: int, message: str) -> tuple[int, str]:
+    return st, json.dumps({"error": message}, ensure_ascii=False, separators=(",", ":"))
+
+
+def _clean(n: object) -> bool:
+    s = str(n or "") if isinstance(n, str) else ""
+    return bool(s) and len(s) <= 120 and bool(_CLEAN.match(s)) and ".." not in s and not re.search(r"[/\\\0]", s) and not re.search(r"[^ -~]", s)
+
+
+def mkdir_in(*, root: object, rel: object, name: object) -> tuple[int, str]:
+    if not _clean(name):
+        return _error(400, "a folder name: no /, . or .., and not hidden")
+    win = isinstance(root, str) and bool(_WIN_ABS.match(root))
+    if not isinstance(root, str) or not (win or root.startswith("/")):
+        return _error(400, "not a root folder")
+    P = ntpath if win else posixpath
+    rel_path = re.sub(r"^[\\/]", "", re.sub(r"[\\/]+$", "", rel)) if isinstance(rel, str) and rel and rel != "." else ""
+    target_abs = P.normpath(P.join(root, rel_path, str(name)))
+    if not os.path.isdir(root):
+        return _error(404, "the root folder is not on this computer")
+    parent = P.dirname(target_abs)
+    if not os.path.isdir(parent):
+        return _error(404, "the parent folder is not on this computer")
+    real_root, real_parent = os.path.realpath(root), os.path.realpath(parent)
+    fold = (lambda s: s.lower()) if win else (lambda s: s)
+    if fold(real_parent) != fold(real_root) and not fold(real_parent).startswith(fold(real_root).rstrip("\\/") + P.sep):
+        return _error(403, "that lies outside the root")
+    target = P.join(real_parent, str(name))
+    try:
+        os.mkdir(target, 0o700)
+    except FileExistsError:
+        return _error(409, "already there")
+    except OSError as e:
+        return _error(500, f"could not create it here ({str(e)[:120]})")
+    return 200, json.dumps({"ok": True, "path": target}, ensure_ascii=False, separators=(",", ":"))