witbitz-code 1.10.1__tar.gz → 1.11.0__tar.gz

{witbitz_code-1.10.1/src/witbitz_code.egg-info → witbitz_code-1.11.0}/PKG-INFO

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "witbitz-code"
-version = "1.10.1"
+version = "1.11.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.10.1 → witbitz_code-1.11.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.10.1"
+__version__ = "1.11.0"

witbitz_code-1.11.0/src/witbitz_code/app.py

@@ -0,0 +1,101 @@
+"""WHICH SPACES APP THIS INSTALL BELONGS TO (the owner, 2026-10-22: "Each code is installed from its own origin" → "A separate
+Witbitz Code install for each app - do it").
+
+The regular app (witbitz-spaces.pages.dev) and the vaulted app (spaces.witbitz.chat / app.witbitz.chat) are separate tenants:
+an account's rooms answer only to their own app. So each app's installer makes its own Witbitz Code — its own folder, its
+own OpenCode ports and sessions, its own page and Start-menu entry, its own updates — and a code scanned from the other
+app is refused with where to install that one from.
+
+One setting says which: WITBITZ_CODE_APP=vaulted (the vaulted app's installer writes it into its shortcuts and launcher;
+`--app vaulted` on any command sets it). Anything else is the regular app — every install made before this, unchanged.
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Any
+
+REGULAR, VAULTED = "regular", "vaulted"
+
+# The hosted (vaulted) app's origins (the tenant t_a7f1); any other origin, or none, is the regular app's.
+VAULTED_ORIGINS = ("https://spaces.witbitz.chat", "https://app.witbitz.chat", "https://witbitz-vault-prod.pages.dev",
+                   "https://witbitz-spaces-vaulted.pages.dev")
+
+_APPS = {
+    REGULAR: {"dir": "code", "port": 4096, "origin": "https://witbitz-spaces.pages.dev",
+              "installer": "https://app.witbitz.chat/code.ps1", "label": "regular app"},
+    # Ports 4296–4395 (proxies 4396–4495): never the regular install's 4096–4195 (proxies 4196–4295).
+    VAULTED: {"dir": "code-vaulted", "port": 4296, "origin": "https://spaces.witbitz.chat",
+              "installer": "https://app.witbitz.chat/code-vaulted.ps1", "label": "vaulted app"},
+}
+PORTS_PER_APP = 100
+
+
+def name() -> str:
+    v = (os.environ.get("WITBITZ_CODE_APP") or "").strip().lower()
+    return VAULTED if v == VAULTED else REGULAR
+
+
+def is_vaulted() -> bool:
+    return name() == VAULTED
+
+
+def of_origin(origin: Any) -> str:
+    """The app an origin belongs to (a pairing's `origin`; none = the regular app, as every pairing before 2026-10-22)."""
+    return VAULTED if origin in VAULTED_ORIGINS else REGULAR
+
+
+def label(which: str | None = None) -> str:
+    return _APPS[which or name()]["label"]
+
+
+def code_dir() -> Path:
+    """This install's folder: pairings, keys, session owners, the page's lock and log."""
+    return Path.home() / ".witbitz" / _APPS[name()]["dir"]
+
+
+def base_port() -> int:
+    return _APPS[name()]["port"]
+
+
+def ports() -> range:
+    """OpenCode's ports for this install's accounts (its proxy on each + 100)."""
+    return range(base_port(), base_port() + PORTS_PER_APP)
+
+
+def origin() -> str:
+    """The app's origin for an account call with no pairing to name it."""
+    return _APPS[name()]["origin"]
+
+
+def installer_url() -> str:
+    return _APPS[name()]["installer"]
+
+
+def take_flag(argv: list[str]) -> list[str]:
+    """`--app vaulted` anywhere in a command → WITBITZ_CODE_APP for this process and everything it starts; the rest back."""
+    out, i = [], 0
+    while i < len(argv):
+        if argv[i] == "--app" and i + 1 < len(argv):
+            os.environ["WITBITZ_CODE_APP"] = VAULTED if argv[i + 1].strip().lower() == VAULTED else REGULAR
+            i += 2
+            continue
+        out.append(argv[i])
+        i += 1
+    return out
+
+
+def display_name() -> str:
+    """The name on this install's Start-menu entry, launcher and Settings → Apps entry (code.ps1's $Named)."""
+    return "Witbitz Code (vaulted app)" if is_vaulted() else "Witbitz Code"
+
+
+def args() -> list[str]:
+    """What a command line this install writes must carry for the program it starts to know its app (a login start, a WSL start)."""
+    return ["--app", VAULTED] if is_vaulted() else []
+
+
+def windows_root(localappdata: str) -> str:
+    """The installer's folder (code.ps1 $root)."""
+    return os.path.join(localappdata, "Witbitz Vaulted" if is_vaulted() else "Witbitz")

{witbitz_code-1.10.1 → witbitz_code-1.11.0}/src/witbitz_code/attachments.py

@@ -22,6 +22,7 @@ from pathlib import Path
 from typing import Any
 
 from . import _js
+from . import app
 from . import pairings as pp
 
 NOTE_HEAD = "The user attached files. They are saved on this computer — open them with the read tool."
@@ -44,7 +45,7 @@ _MIME = {"pdf": "application/pdf", "png": "image/png", "jpg": "image/jpeg", "jpe
 
 
 def default_root() -> Path:
-    return Path(os.environ.get("WITBITZ_CODE_ATTACHMENTS") or Path.home() / ".witbitz" / "code" / "attachments")
+    return Path(os.environ.get("WITBITZ_CODE_ATTACHMENTS") or app.code_dir() / "attachments")
 
 
 def safe_name(name: Any) -> str:

{witbitz_code-1.10.1 → witbitz_code-1.11.0}/src/witbitz_code/cli.py

@@ -23,7 +23,7 @@ from typing import Any
 
 import httpx
 
-from . import __version__
+from . import __version__, app
 from . import pair as pair_cmd
 from . import pairings as pp
 from . import browse as browse_mod, codekeys, codetools, confidential, keys, models, plugins, policy, ports, toolsetup, uninstall as uninstall_mod, winagent, winbg, winconsole, wizard, wslstart
@@ -163,8 +163,8 @@ _SETUP_LOCK = asyncio.Lock()
 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
+    port_n = to_number(_flag(args, "--port", str(app.base_port())))
+    port = int(port_n) if truthy(port_n) and port_n == port_n and float(port_n).is_integer() else app.base_port()
     everything = pp.load_pairings(log=lambda _m: None)
     if not everything:
         _err("witbitz-code: this computer is not paired yet — run: witbitz-code setup")
@@ -335,8 +335,8 @@ async def _check_keys_every(live_keys: codekeys.LiveKeys, http: httpx.AsyncClien
 
 
 async def setup(args: list[str]) -> int:
-    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
+    port_n = to_number(_flag(args, "--port", str(app.base_port())))
+    port = int(port_n) if truthy(port_n) and port_n == port_n and float(port_n).is_integer() else app.base_port()
     from . import net  # noqa: PLC0415
 
     client = net.new_client()
@@ -446,7 +446,23 @@ async def ui_command(args: list[str]) -> int:
         await http.aclose()
 
 
+def _own_bin_first() -> None:
+    """Windows: this install's own bin (OpenCode, uv, Git) first on PATH — the vaulted app's install is not on the user PATH
+    (two installs must not fight over `witbitz-code`), and its shortcuts start Python directly. The installer's layout:
+    <root>\\tools\\witbitz-code\\Scripts\\python(w).exe beside <root>\\bin."""
+    if sys.platform != "win32":
+        return
+    try:
+        b = Path(sys.executable).resolve().parents[3] / "bin"
+        if (b / "opencode.exe").is_file() and str(b) not in os.environ.get("PATH", "").split(os.pathsep):
+            os.environ["PATH"] = str(b) + os.pathsep + os.environ.get("PATH", "")
+    except (OSError, IndexError):
+        pass
+
+
 async def _main(argv: list[str]) -> int:
+    argv = app.take_flag(argv)  # `--app vaulted`: this install is the vaulted app's (app.py)
+    _own_bin_first()
     cmd, rest = (argv[0], argv[1:]) if argv else ("", [])
     if cmd == "uninstall":
         return await uninstall(rest)

{witbitz_code-1.10.1 → witbitz_code-1.11.0}/src/witbitz_code/connector.py

@@ -31,6 +31,7 @@ from urllib.parse import urlsplit
 import httpx
 
 from . import _js
+from . import app
 from .asks import ASK_FRAME, AskBook
 from .folders import FOLDER_ROUTE, folder_route
 from .attachments import (ATTACHMENT_ROUTE, MAX_FILE_BYTES, attachment_rule, default_root, prune_attachments,
@@ -64,7 +65,7 @@ _URI_SAFE = "-_.!~*'()"  # encodeURIComponent
 
 def default_auto_dir() -> Path:
     """Auto mode's state (per pairing) and its verdict log — the JS connector's AUTO_DIR."""
-    return Path(os.environ.get("WITBITZ_CODE_AUTO_DIR") or Path.home() / ".witbitz" / "code")
+    return Path(os.environ.get("WITBITZ_CODE_AUTO_DIR") or app.code_dir())
 
 
 def _round(x: float) -> int:

{witbitz_code-1.10.1 → witbitz_code-1.11.0}/src/witbitz_code/net.py

@@ -12,6 +12,7 @@ from typing import Any
 import httpx
 
 from . import _js
+from . import app
 
 API = "https://api.witbitz.chat/v1/space"
 ORIGIN = "https://witbitz-spaces.pages.dev"
@@ -49,7 +50,7 @@ def make_api_call(client: httpx.AsyncClient, origin: str | None = None) -> ApiCa
     """POST {op:'state', …} to the account API, as the Spaces app would (same Origin). `origin`: the app this account was
     paired from (a pairing's `origin`); none → RC_ORIGIN, else the regular app."""
     api = os.environ.get("RC_BASE") or API
-    origin = app_origin(origin) or os.environ.get("RC_ORIGIN") or ORIGIN
+    origin = app_origin(origin) or os.environ.get("RC_ORIGIN") or app.origin()
 
     async def call(body: dict) -> ApiReply:
         r = await client.post(api, content=_js.stringify(body).encode("utf-8"),

{witbitz_code-1.10.1 → witbitz_code-1.11.0}/src/witbitz_code/pair.py

@@ -19,6 +19,7 @@ from typing import Any
 from . import codekeys
 from . import account as acct
 from . import link, net
+from . import app
 from . import pairings as pp
 from ._js import UNDEFINED, number_str, to_number, truthy
 from .connector import START_HINT
@@ -265,6 +266,12 @@ async def _run(args: Args, call: Any, link_fn: LinkFn | None, out: Callable, err
     if not account:
         err("witbitz-code: pairing did not complete — nothing changed.")
         return 1
+    # EACH APP ITS OWN INSTALL (app.py; the owner, 2026-10-22): a code scanned from the other app is not paired here.
+    came = app.of_origin(account.get("origin")) if account.get("origin") else app.name()
+    if came != app.name():
+        err(f"witbitz-code: ✖ that code came from the {app.label(came)} — this Witbitz Code is the {app.label()}'s. "
+            f"Install the {app.label(came)}'s own from it: Code → Computers → Add a computer. Nothing changed.")
+        return 1
     port = None if args.opencode_url else pp.next_port(doc, account["idx"]["room"])  # another account: its own OpenCode
     u = pp.upsert_pairing(doc, account=account.get("email") or "", idx=account["idx"], name=args.name,
                           opencode_url=args.opencode_url or (f"http://127.0.0.1:{port}" if port else UNDEFINED),

{witbitz_code-1.10.1 → witbitz_code-1.11.0}/src/witbitz_code/pairings.py

@@ -24,6 +24,7 @@ from pathlib import Path
 from typing import Any
 
 from . import _js
+from . import app as app_mod
 from ._js import NOT_LT, UNDEFINED, WS, strict_eq, truthy
 from .relay import RELAY_URL, new_relay_secret
 
@@ -32,12 +33,12 @@ DEFAULT_OPENCODE_URL = "http://127.0.0.1:4096"
 
 def pairings_path() -> Path:
     env = os.environ.get("WITBITZ_CODE_PAIRINGS")
-    return Path(env) if env else Path.home() / ".witbitz" / "code" / "pairings.json"
+    return Path(env) if env else app_mod.code_dir() / "pairings.json"  # this install's app (app.py)
 
 
 def env_path() -> Path:
     env = os.environ.get("OPENCODE_ENV_FILE")
-    return Path(env) if env else Path.home() / ".opencode-server.env"
+    return Path(env) if env else (app_mod.code_dir() / "opencode-server.env" if app_mod.is_vaulted() else Path.home() / ".opencode-server.env")
 
 
 # ── the env file ──────────────────────────────────────────────────────────────────────────────────────────────────────
@@ -167,13 +168,12 @@ def remove_pairings(doc: Any, account: str = "", computer_id: str = "") -> dict:
 
 
 # The hosted ("vaulted") app's origins (the tenant t_a7f1); any other origin, or none, is the regular app.
-VAULTED_ORIGINS = ("https://spaces.witbitz.chat", "https://app.witbitz.chat", "https://witbitz-vault-prod.pages.dev",
-                   "https://witbitz-spaces-vaulted.pages.dev")
+VAULTED_ORIGINS = app_mod.VAULTED_ORIGINS
 
 
 def app_label(p: Any) -> str:
     """Which app a pairing belongs to, in words — two pairings of one email differ only in this (the owner, 2026-10-22)."""
-    return "vaulted app" if isinstance(p, dict) and p.get("origin") in VAULTED_ORIGINS else "regular app"
+    return app_mod.label(app_mod.of_origin(p.get("origin") if isinstance(p, dict) else None))
 
 
 # EACH ACCOUNT ITS OWN OPENCODE (the owner, 2026-10-22: one account's sessions showed in the other's — "they should be
@@ -190,13 +190,15 @@ def next_port(doc: Any, room: str) -> int | None:
     """The OpenCode port for a NEW pairing of `room`'s account: None = keep (already paired, or the first one here → 4096);
     else the first port no other pairing uses — each account its own OpenCode (= the page's _pair_port)."""
     cur = norm_pairings(doc)["pairings"]
-    if not cur or any(p["idx"]["room"] == room for p in cur):
+    if any(p["idx"]["room"] == room for p in cur):
         return None
+    if not cur:
+        return app_mod.base_port() if app_mod.is_vaulted() else None  # the vaulted install's first: its own range
     used = set()
     for p in cur:
         m = re.search(r":(\d+)/*$", str(p.get("opencodeUrl") or "http://127.0.0.1:4096"))
         used.add(int(m.group(1)) if m else 4096)
-    return next((n for n in range(4096, 4196) if n not in used), None)
+    return next((n for n in app_mod.ports() if n not in used), None)
 
 
 def stores_path() -> Path:
@@ -224,6 +226,8 @@ def default_store_owner(pairings: list[dict]) -> str:
 def store_dir(p: Any, pairings: list[dict]) -> Path | None:
     """None = OpenCode's default store (the first account's); else this account's own folder."""
     key = store_key(p)
+    if app_mod.is_vaulted():  # OpenCode's default store is the regular install's: every vaulted account has its own
+        return pairings_path().parent / "accounts" / key
     return None if key == default_store_owner(pairings) else pairings_path().parent / "accounts" / key
 
 

{witbitz_code-1.10.1 → witbitz_code-1.11.0}/src/witbitz_code/selfupdate.py

@@ -23,6 +23,7 @@ from collections.abc import Awaitable, Callable
 from typing import Any
 
 from . import __version__, uninstall
+from . import app
 
 INSTALLER_URL = "https://app.witbitz.chat/code.ps1"
 CHECK_EVERY_S = 3600  # while the page is open (its status poll); one small file from Cloudflare
@@ -75,7 +76,7 @@ class Updates:
             return
         self.checked_at = self._now()
         try:
-            v = parse_pin(await self._fetch(INSTALLER_URL))
+            v = parse_pin(await self._fetch(app.installer_url()))
             if v:
                 self.latest, self.why = v, ""
             else:
@@ -99,7 +100,7 @@ class Updates:
             return {"ok": False, "why": self.why or f"witbitz-code {self.current} is the released version"}
         v = st["latest"]
         if st["kind"] == "installer":
-            self._launch(["powershell.exe", "-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", f"irm {INSTALLER_URL} | iex"])
+            self._launch(["powershell.exe", "-NoProfile", "-ExecutionPolicy", "Bypass", "-Command", f"irm {app.installer_url()} | iex"])
             return {"ok": True, "kind": "installer", "message": f"The installer is updating witbitz-code to {v} in its own window; this page opens again when it is done."}
         if st["kind"] == "pipx":
             r = self._run(["pipx", "install", "--force", "--pip-args=--no-cache-dir", f"witbitz-code=={v}"])  # pip caches the index ~10 min

{witbitz_code-1.10.1 → witbitz_code-1.11.0}/src/witbitz_code/ui.py

@@ -37,6 +37,7 @@ from typing import Any, Awaitable, Callable
 
 from . import __version__, browsetree, devicelink, link, net, ports, qr, seccheck, selfupdate, uitools, uninstall, winbg, wizard, wslstart
 from . import pair as pair_cmd
+from . import app
 from . import pairings as pp
 
 UI_PORT_FROM = 4290
@@ -163,7 +164,7 @@ class Manager:
 
     def port(self) -> int:
         ps = self.ports()
-        return ps[0] if len(ps) == 1 else 4096
+        return ps[0] if len(ps) == 1 else app.base_port()
 
     def ports(self) -> list[int]:
         """Every port a pairing here uses — one OpenCode each."""
@@ -236,7 +237,7 @@ class Manager:
                 serving = {"state": "elsewhere", "port": el["port"], "owners": el["owners"]}
         # Hourly while the page is open; within minutes when it is opened or looked at again (fresh). Never waited for.
         asyncio.ensure_future(self.updates.check(fresh=fresh))
-        return {"version": __version__, "update": self.updates.status(), "computer": self.label, "paired": paired, "serving": serving, "pair": pair,
+        return {"version": __version__, "app": app.name(), "update": self.updates.status(), "computer": self.label, "paired": paired, "serving": serving, "pair": pair,
                 "login": self.login(), "busy": self.busy, "background": self.background,
                 "tools": await asyncio.to_thread(self.tools.status),
                 "tree": await asyncio.to_thread(self.tree.status), "security": self.security.peek(), "log": list(self.log)[-14:]}
@@ -341,10 +342,10 @@ class Manager:
         (the owner, 2026-10-22: one account's sessions must not show in another's). Serving is stopped while a code is up,
         so a paired port is skipped by the list, not by listening."""
         used = set(self.ports())
-        for p in range(4096, 4196):  # OpenCode's port and its proxy's (+100) — WSL and Windows share them on one laptop
+        for p in app.ports():  # OpenCode's port and its proxy's (+100) — WSL and Windows share them on one laptop; this app's range (app.py)
             if p not in used and not await self._is_listening(p) and not await self._is_listening(p + 100):
                 return p
-        return 4096
+        return app.base_port()
 
     async def start_pairing(self) -> dict:
         if self.pair_task and not self.pair_task.done():

{witbitz_code-1.10.1 → witbitz_code-1.11.0}/src/witbitz_code/ui_static/app.js

@@ -43,6 +43,10 @@ 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 : '')
+  // WHICH APP (app.py; the owner, 2026-10-22: a separate install for each app) — the vaulted app's says so, here and in the tab
+  const vaulted = s.app === 'vaulted'
+  $('appName').textContent = vaulted ? 'Witbitz Code · vaulted app' : 'Witbitz Code'
+  document.title = vaulted ? 'Witbitz Code (vaulted app)' : 'Witbitz Code'
   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

{witbitz_code-1.10.1 → witbitz_code-1.11.0}/src/witbitz_code/ui_static/index.html

@@ -10,7 +10,7 @@
 <body>
 <main>
   <header>
-    <h1>Witbitz Code</h1>
+    <h1 id="appName">Witbitz Code</h1>
     <p id="computer" class="sub">This computer</p>
   </header>
 

{witbitz_code-1.10.1 → witbitz_code-1.11.0}/src/witbitz_code/uninstall.py

@@ -24,6 +24,7 @@ from pathlib import Path
 from typing import Any
 
 from . import keys, plugins, ports
+from . import app
 from . import pairings as pp
 from .wizard import find_opencode
 
@@ -344,7 +345,7 @@ class Deps:
     remove_opencode: bool = False
     all_pairings: Callable[[], list] = lambda: pp.load_pairings(log=lambda _m: None)
     unpair: Callable[[dict], Awaitable[dict]] = None  # type: ignore[assignment]
-    code_dir: str = field(default_factory=lambda: str(Path.home() / ".witbitz" / "code"))
+    code_dir: str = field(default_factory=lambda: str(app.code_dir()))
     has_keys: Callable[[], list] = None  # type: ignore[assignment]
     delete_keys: Callable[[], None] = None  # type: ignore[assignment]
     remove_path: Callable[[str], None] = lambda p: (shutil.rmtree(p, ignore_errors=True) if os.path.isdir(p) and not os.path.islink(p) else Path(p).unlink(missing_ok=True))

{witbitz_code-1.10.1 → witbitz_code-1.11.0}/src/witbitz_code/wslstart.py

@@ -25,7 +25,7 @@ import subprocess
 import sys
 from typing import Callable
 
-from . import ports
+from . import app, ports
 
 POWERSHELL = "/mnt/c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe"
 STARTUP = "[Environment]::GetFolderPath('Startup')"
@@ -37,7 +37,8 @@ WIN_QUIET = ["ui", "--no-browser"]  # native Windows: pythonw knows it has no wi
 
 
 def shortcut_name(distro: str) -> str:
-    return f"Witbitz Code (WSL {distro}).lnk" if distro else "Witbitz Code (WSL).lnk"
+    v = " · vaulted app" if app.is_vaulted() else ""  # each app its own install (app.py)
+    return f"Witbitz Code (WSL {distro}{v}).lnk" if distro else f"Witbitz Code (WSL{v}).lnk"
 
 
 def _join(parts: list[str]) -> str:
@@ -197,12 +198,12 @@ def launch_background(*, ps: Callable[[str], tuple[int, str]] = run_ps, which: C
         return False, "witbitz-code is not on PATH"
     copy = copy or copy_icon
     distro = os.environ.get("WSL_DISTRO_NAME", "")
-    args = headless_args(distro, getpass.getuser(), wsl_command(exe), ["ui", "--hidden"])
+    args = headless_args(distro, getpass.getuser(), wsl_command(exe), ["ui", "--hidden", *app.args()])
     # The Start-menu entry first (it opens this page again, starting it if it is not running), then the start itself.
     icon = WSL_ICON if copy(ps=ps) else ""
     menu = enable_script(menu_name(distro), args, folder=PROGRAMS, target=CONHOST, icon=icon)
     # 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(), wsl_command(exe), UI_QUIET)
+    quiet = headless_args(distro, getpass.getuser(), wsl_command(exe), [*UI_QUIET, *app.args()])
     login = (f"if (Test-Path (Join-Path ({STARTUP}) {_q(shortcut_name(distro))})) {{ "
              f"{enable_script(shortcut_name(distro), quiet, target=CONHOST, icon=icon)} | Out-Null }}")
     code, out = ps(f"try {{ {menu} | Out-Null; {login} }} catch {{ }}; {launch_script(args)}")
@@ -218,13 +219,13 @@ def windows_startup_spec(env: dict | None = None, which: Callable[[str], str | N
     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),
+        return {"name": app.display_name() + ".lnk", "args": _join(["-m", "witbitz_code", *WIN_QUIET, *app.args()]), "target": _q(pyw),
                 "icon": _q(icon_file("witbitz-code.ico"))}
-    launcher = os.path.join(env.get("LOCALAPPDATA", ""), "Witbitz", "Witbitz Code.cmd")
+    launcher = os.path.join(app.windows_root(env.get("LOCALAPPDATA", "")), app.display_name() + ".cmd")  # it sets WITBITZ_CODE_APP
     if env.get("LOCALAPPDATA") and exists(launcher):
-        return {"name": "Witbitz Code.lnk", "args": "--no-browser", "target": _q(launcher)}
+        return {"name": app.display_name() + ".lnk", "args": "--no-browser", "target": _q(launcher)}
     exe = which("witbitz-code")
-    return {"name": "Witbitz Code.lnk", "args": _join(WIN_QUIET), "target": _q(exe)} if exe else None
+    return {"name": app.display_name() + ".lnk", "args": _join([*WIN_QUIET, *app.args()]), "target": _q(exe)} if exe else None
 
 
 def login_spec() -> dict | None:

{witbitz_code-1.10.1 → witbitz_code-1.11.0/src/witbitz_code.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: witbitz-code
-Version: 1.10.1
+Version: 1.11.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.10.1 → witbitz_code-1.11.0}/src/witbitz_code.egg-info/SOURCES.txt

@@ -5,6 +5,7 @@ src/witbitz_code/__init__.py
 src/witbitz_code/__main__.py
 src/witbitz_code/_js.py
 src/witbitz_code/account.py
+src/witbitz_code/app.py
 src/witbitz_code/asks.py
 src/witbitz_code/attachments.py
 src/witbitz_code/auto.py

{witbitz_code-1.10.1 → witbitz_code-1.11.0}/tests/test_pair_flows.py

@@ -304,9 +304,11 @@ def test_a_new_pairing_on_wsl_is_named_for_wsl(monkeypatch):
     assert pp.hostname() == "my-laptop"
 
 
-def test_a_pairing_from_the_hosted_app_writes_that_app_s_account_and_remembers_it():
+def test_a_pairing_from_the_hosted_app_writes_that_app_s_account_and_remembers_it(monkeypatch):
     """The owner, 2026-10-22: a second account added from the vaulted app failed "computers read refused (404)" — its
-    rooms answer only to the hosted app's origin. The relay that answered the scan names the app; each pairing keeps it."""
+    rooms answer only to the hosted app's origin. The relay that answered the scan names the app; each pairing keeps it.
+    Since the same day each app has its OWN install (app.py): this is the vaulted app's, and the regular app's code is refused."""
+    monkeypatch.setenv("WITBITZ_CODE_APP", "vaulted")
     regular, hosted = MockApi(), MockApi()
     asked = []
 
@@ -328,16 +330,16 @@ def test_a_pairing_from_the_hosted_app_writes_that_app_s_account_and_remembers_i
     assert regular.writes == [] and hosted.writes, "the account was written through the hosted app's origin only"
     p = pp.read_pairings()["pairings"][0]
     assert p["origin"] == "https://spaces.witbitz.chat"
+    assert p["opencodeUrl"] == "http://127.0.0.1:4296", "the vaulted install's own OpenCode range"
 
     async def link_fn2():
         return {"email": "work@y", "idx": IDX2, "master": "M" * 43, "anchor": {**ANCHOR, "email": "work@y"},
                 "origin": "https://witbitz-spaces.pages.dev"}
 
-    asked.clear()
-    assert run(pair.main([], call=call, link_fn=link_fn2, keys=keys, **Capture().kw())) == 0
-    assert set(asked) == {"https://witbitz-spaces.pages.dev"}, "a regular-app pairing writes through its own origin"
-    q = next(x for x in pp.read_pairings()["pairings"] if x["account"] == "work@y")
-    assert q["origin"] == "https://witbitz-spaces.pages.dev"
+    cap = Capture()
+    assert run(pair.main([], call=call, link_fn=link_fn2, keys=keys, **cap.kw())) == 1
+    assert "came from the regular app" in cap.text() and "Nothing changed" in cap.text()
+    assert [x["account"] for x in pp.read_pairings()["pairings"]] == ["me@x"], "the regular app's code is not paired here"
 
     asked.clear()
     assert run(pair.main(["--rotate", "--account", "me@x"], call=call, **Capture().kw())) == 0
@@ -349,6 +351,32 @@ def test_a_pairing_from_the_hosted_app_writes_that_app_s_account_and_remembers_i
     assert len(hosted.writes) > n, "the unpair tombstone goes to the hosted app's account too"
 
 
+def test_the_regular_install_refuses_a_code_from_the_vaulted_app(monkeypatch):
+    monkeypatch.delenv("WITBITZ_CODE_APP", raising=False)
+
+    async def link_fn():
+        return {"email": "me@x", "idx": IDX, "master": "M" * 43, "anchor": ANCHOR, "origin": "https://spaces.witbitz.chat"}
+
+    cap = Capture()
+    assert run(pair.main([], call=MockApi().call, link_fn=link_fn, keys=FakeKeys(), **cap.kw())) == 1
+    assert "came from the vaulted app" in cap.text() and "Code → Computers → Add a computer" in cap.text()
+    assert pp.read_pairings()["pairings"] == []
+
+
+def test_each_app_has_its_own_folder_ports_installer_and_store(monkeypatch, tmp_path):
+    from witbitz_code import app
+    monkeypatch.setattr(app.Path, "home", lambda: tmp_path)
+    monkeypatch.delenv("WITBITZ_CODE_APP", raising=False)
+    assert (app.code_dir(), app.base_port(), app.installer_url()) == (tmp_path / ".witbitz" / "code", 4096, "https://app.witbitz.chat/code.ps1")
+    monkeypatch.setenv("WITBITZ_CODE_APP", "vaulted")
+    assert (app.code_dir(), app.base_port(), app.installer_url()) == (tmp_path / ".witbitz" / "code-vaulted", 4296, "https://app.witbitz.chat/code-vaulted.ps1")
+    assert set(app.ports()).isdisjoint(range(4096, 4296)), "never the regular install's OpenCode or proxy ports"
+    me = {"account": "me@x", "origin": "https://spaces.witbitz.chat"}
+    assert pp.store_dir(me, [me]) is not None, "OpenCode's default store is the regular install's"
+    monkeypatch.delenv("WITBITZ_CODE_APP")
+    assert app.take_flag(["ui", "--app", "vaulted", "--no-browser"]) == ["ui", "--no-browser"] and app.is_vaulted()
+
+
 def test_call_for_ignores_anything_that_is_not_an_https_origin():
     from witbitz_code import net
 

{witbitz_code-1.10.1 → witbitz_code-1.11.0}/tests/test_wslstart.py

@@ -101,3 +101,18 @@ def test_the_icon_is_written_into_windows_local_app_data_from_this_side(tmp_path
     assert ok and (win / "Witbitz-WSL" / "witbitz-code-wsl.ico").read_bytes() == open(ws.icon_file("witbitz-code-wsl.ico"), "rb").read()
     assert ws.copy_icon(ps=lambda s: (-1, ""), to_linux=lambda p: str(win)) is False
     assert ws.copy_icon(ps=lambda s: (0, "ok"), to_linux=lambda p: "ok") is False, "not a Windows folder: never written"
+
+
+def test_the_vaulted_app_s_install_starts_as_itself(monkeypatch):
+    """Each app its own install (app.py; the owner, 2026-10-22): the vaulted one's login start, Start-menu entry and WSL start
+    carry `--app vaulted` and its own names — a start that forgot would come back as the regular app's Witbitz Code."""
+    import os
+    from witbitz_code import wslstart as ws
+    monkeypatch.setenv("WITBITZ_CODE_APP", "vaulted")
+    exe = r"C:\Users\a\AppData\Local\Witbitz Vaulted\tools\witbitz-code\Scripts\python.exe"
+    pyw = os.path.join(os.path.dirname(exe), "pythonw.exe")
+    spec = ws.windows_startup_spec(env={"LOCALAPPDATA": "L"}, exists=lambda p: p == pyw, executable=exe)
+    assert spec["name"] == "Witbitz Code (vaulted app).lnk" and spec["args"].endswith("ui --no-browser --app vaulted")
+    launcher = ws.windows_startup_spec(env={"LOCALAPPDATA": "L"}, exists=lambda p: p.endswith("Witbitz Code (vaulted app).cmd"), executable=exe)
+    assert "Witbitz Vaulted" in launcher["target"] and launcher["name"] == "Witbitz Code (vaulted app).lnk"
+    assert ws.shortcut_name("Ubuntu") == "Witbitz Code (WSL Ubuntu · vaulted app).lnk"