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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: witbitz-code
-Version: 1.3.8
+Version: 1.3.9
 Summary: Reach OpenCode on this computer from the Witbitz Spaces Code section, through an end-to-end sealed relay.
 Author: Witbitz
 License-Expression: MIT
@@ -92,6 +92,10 @@ The same thing one step at a time: install OpenCode (`curl -fsSL https://opencod
 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`.
 
+**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
 all the accounts are yours. If a second account belongs to **another person**, run a separate OpenCode for them

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

@@ -66,6 +66,10 @@ The same thing one step at a time: install OpenCode (`curl -fsSL https://opencod
 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`.
 
+**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
 all the accounts are yours. If a second account belongs to **another person**, run a separate OpenCode for them

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "witbitz-code"
-version = "1.3.8"
+version = "1.3.9"
 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.3.8 → witbitz_code-1.3.9}/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.3.9"

{witbitz_code-1.3.8 → witbitz_code-1.3.9}/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
@@ -396,6 +398,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.3.9/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.3.9/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=(",", ":"))

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: witbitz-code
-Version: 1.3.8
+Version: 1.3.9
 Summary: Reach OpenCode on this computer from the Witbitz Spaces Code section, through an end-to-end sealed relay.
 Author: Witbitz
 License-Expression: MIT
@@ -92,6 +92,10 @@ The same thing one step at a time: install OpenCode (`curl -fsSL https://opencod
 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`.
 
+**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
 all the accounts are yours. If a second account belongs to **another person**, run a separate OpenCode for them

{witbitz_code-1.3.8 → witbitz_code-1.3.9}/src/witbitz_code.egg-info/SOURCES.txt

@@ -18,10 +18,12 @@ src/witbitz_code/confidential.py
 src/witbitz_code/confidential_models.json
 src/witbitz_code/connector.py
 src/witbitz_code/devicelink.py
+src/witbitz_code/dirs.py
 src/witbitz_code/folders.py
 src/witbitz_code/gateway.py
 src/witbitz_code/keys.py
 src/witbitz_code/link.py
+src/witbitz_code/mkdir.py
 src/witbitz_code/models.py
 src/witbitz_code/net.py
 src/witbitz_code/offered_models.json
@@ -63,6 +65,7 @@ tests/test_codetools.py
 tests/test_confidential.py
 tests/test_connector_e2e.py
 tests/test_devicelink.py
+tests/test_dirs.py
 tests/test_files_and_compress.py
 tests/test_folders.py
 tests/test_outputs.py

{witbitz_code-1.3.8 → witbitz_code-1.3.9}/tests/test_connector_e2e.py

@@ -323,6 +323,29 @@ async def conformance(rig: Rig, connector) -> None:
         assert (await client.call("POST", "/witbitz/seen", "not an object"))["st"] == 400
         assert (await client.call("PUT", "/witbitz/seen", {}))["st"] == 403
         assert json.loads((await client.call("GET", "/witbitz/seen"))["b"]) == {"since": 3000, "at": {"ses_a": 9000, "ses_b": 8000, "ses_c": 6000}}
+
+        # BROWSE + NEW FOLDER (dirs.py = tools/code-dirs.mjs, mkdir.py = tools/code-mkdir.mjs): the New-session picker past ~
+        # (the owner, 2026-10-09: "Or drives (like D:)"), answered by the connector itself — the same on both. Before 1.3.9
+        # the Python connector had no mkdir route at all: "New folder" was refused on every pipx install.
+        top = Path(tempfile.mkdtemp(prefix="wb-conf-dirs-"))
+        for d in ("Beta", "alpha", ".hidden", "$junk"):
+            (top / d).mkdir()
+        (top / "f.txt").write_text("x")
+        listing = await client.call("GET", "/witbitz/dirs?path=" + urllib.parse.quote(str(top) + "/", safe=""))
+        assert listing["st"] == 200, listing
+        assert json.loads(listing["b"]) == {"path": str(top), "parent": str(top.parent),
+                                            "dirs": [{"name": "alpha", "path": str(top / "alpha")}, {"name": "Beta", "path": str(top / "Beta")}]}
+        assert json.loads((await client.call("GET", "/witbitz/dirs"))["b"])["path"] == "/"
+        assert (await client.call("GET", "/witbitz/dirs?path=rel%2Fx"))["st"] == 400
+        assert (await client.call("GET", "/witbitz/dirs?path=" + urllib.parse.quote(str(top / "nope"), safe="")))["st"] == 404
+        mk = lambda: "/witbitz/mkdir?directory=" + urllib.parse.quote(str(top), safe="") + "&path=."  # noqa: E731
+        made = await client.call("POST", mk(), {"name": "new one"})
+        assert made["st"] == 200 and (top / "new one").is_dir() and json.loads(made["b"])["ok"] is True
+        assert (await client.call("POST", mk(), {"name": "new one"}))["st"] == 409
+        assert (await client.call("POST", mk(), {"name": "..\\escape"}))["st"] == 400
+        assert (await client.call("POST", mk(), {"nope": 1}))["st"] == 400
+        assert (await client.call("POST", "/witbitz/mkdir?directory=rel&path=.", {"name": "x"}))["st"] == 400
+        assert not any(h.get("url", "").startswith("/witbitz") for h in rig.oc.seen_copy()), "OpenCode never sees the routes"
     finally:
         await client.peer.aclose()
         await connector.stop()

witbitz_code-1.3.9/tests/test_dirs.py

@@ -0,0 +1,60 @@
+"""dirs.py — the New-session picker's "browse this computer" — held to tools/code-dirs.mjs on Windows-shaped fakes (the real
+folders and both connectors are in test_connector_e2e's conformance sequence). The owner, 2026-10-09: "Or drives (like D:)"."""
+
+from __future__ import annotations
+
+import json
+
+from conftest import requires_node, run_node
+
+from witbitz_code import dirs, mkdir
+
+WIN_FS = {
+    "C:\\": [("Users", True, False), ("$Recycle.Bin", True, False), ("System Volume Information", True, False), ("pagefile.sys", False, False)],
+    "C:\\Users\\shter": [("Documents", True, False), ("Application Data", False, True), ("OneDrive", False, True), ("zeta", True, False), ("Alpha", True, False)],
+    "C:\\Users\\shter\\OneDrive": [],
+}
+CASES = [{"path": ""}, {"path": "C:/"}, {"path": "C:\\Users\\shter\\"}, {"path": "/home"}, {"path": "C:\\Windows\\nope"}, {"path": "D:"}]
+
+
+def win_readdir(p: str) -> list:
+    if p in WIN_FS:
+        return WIN_FS[p]
+    raise (PermissionError if p.endswith("Application Data") else FileNotFoundError)(p)
+
+
+def py(case: dict) -> dict:
+    st, b = dirs.list_dirs(path=case["path"], platform="win32", readdir=win_readdir, is_dir=lambda p: True, drives=lambda: ["C:", "D:"])
+    return {"st": st, **json.loads(b)}
+
+
+def test_windows_drives_roots_and_junctions_that_deny_listing():
+    assert py({"path": ""}) == {"st": 200, "path": "", "parent": None, "dirs": [{"name": "C:", "path": "C:\\"}, {"name": "D:", "path": "D:\\"}]}
+    c = py({"path": "C:/"})
+    assert c["path"] == "C:\\" and c["parent"] == "" and c["dirs"] == [{"name": "Users", "path": "C:\\Users"}]
+    h = py({"path": "C:\\Users\\shter\\"})
+    assert h["parent"] == "C:\\Users" and [d["name"] for d in h["dirs"]] == ["Alpha", "Documents", "OneDrive", "zeta"]
+    assert py({"path": "/home"})["st"] == 400 and py({"path": "C:\\Windows\\nope"})["st"] == 404
+
+
+@requires_node
+def test_the_javascript_lists_the_same():
+    js = run_node("""
+      import { listDirs } from '@TOOLS@/code-dirs.mjs'
+      const fs = INPUT.fs
+      const readdir = (p) => {
+        if (p in fs) return fs[p].map(([name, dir, link]) => ({ name, isDirectory: () => dir, isSymbolicLink: () => link }))
+        throw Object.assign(new Error(p), { code: p.endsWith('Application Data') ? 'EPERM' : 'ENOENT' })
+      }
+      OUT(INPUT.cases.map((c) => { const o = listDirs({ path: c.path, platform: 'win32', readdir, isDir: () => true, drives: () => ['C:', 'D:'] }); return { st: o.st, ...JSON.parse(o.b) } }))
+    """, {"fs": WIN_FS, "cases": CASES})
+    assert js == [py(c) for c in CASES]
+
+
+def test_new_folder_names_are_one_clean_leaf_on_both_kinds_of_root(tmp_path):
+    for bad in ["..", ".x", "a/b", "a\\b", "\\x", "", "a\x00b", "é"]:
+        assert mkdir.mkdir_in(root=str(tmp_path), rel=".", name=bad)[0] == 400, bad
+    assert mkdir.mkdir_in(root="relative", rel=".", name="x")[0] == 400
+    assert mkdir.mkdir_in(root="C:\\Users\\nobody-here", rel=".", name="x")[0] == 404, "a Windows root is a root (not on this computer)"
+    assert mkdir.mkdir_in(root=str(tmp_path), rel="..", name="x")[0] == 403, "never above the root"
+    assert mkdir.mkdir_in(root=str(tmp_path), rel=".", name="ok one")[0] == 200 and (tmp_path / "ok one").is_dir()