webbee 0.6.4__tar.gz → 0.6.6__tar.gz

{webbee-0.6.4 → webbee-0.6.6}/CHANGELOG.md

@@ -1,11 +1,17 @@
 # Changelog
 
-## 0.6.4
+## 0.6.6
 
-* **imperal-mcp 0.8.3 at least**: the prompt hook's frame is composed by the kernel to the size the shell keeps.
-  Works with the kernel's package 0.8.5 of 2026-10-25: a run started in the background is proven by the read of its
-  log, every parallel call keeps its result, an expectation is checked on the whole answer, the conversation lens holds
-  the request being worked on, WORLD takes the code map's commit and leaves old facts of a machine out.
+* **The upgrade's lock is the user's own**: it lives in webbee's data folder (only this user can write it), never in
+  the shared temp folder where another user could hold every upgrade back; a lock another user made is ignored.
+
+## 0.6.5
+
+* **Two webbees started together never break the install**: the upgrade at the start runs one at a time (a lock per
+  user); the second start waits for the first and starts on the release it installed. A pipx install is upgraded in
+  place (`pipx runpip`), never deleted and built again; the new release must import before webbee starts on it, else
+  it is installed once more (live 2026-10-25: a start in the middle of another's reinstall failed on
+  `No module named 'pygments.styles'`).
 
 ## 0.6.4
 

{webbee-0.6.4 → webbee-0.6.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: webbee
-Version: 0.6.4
+Version: 0.6.6
 Summary: Webbee 🐝 — the Imperal Cloud coding agent in your terminal
 Project-URL: Homepage, https://imperal.io
 Project-URL: Documentation, https://docs.imperal.io

{webbee-0.6.4 → webbee-0.6.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "webbee"
-version = "0.6.4"
+version = "0.6.6"
 description = "Webbee 🐝 — the Imperal Cloud coding agent in your terminal"
 readme = "README.md"
 license = "GPL-3.0-or-later"

webbee-0.6.6/src/webbee/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.6.6"

{webbee-0.6.4 → webbee-0.6.6}/src/webbee/autoupdate.py

@@ -12,6 +12,7 @@ import os
 import shutil
 import subprocess
 import sys
+import time
 
 DIST = "webbee"
 MCP = "imperal-mcp"
@@ -22,6 +23,10 @@ OFF_ENV = "WEBBEE_NO_AUTOUPDATE"           # 1: never upgrade at the start (CI,
 DONE_ENV = "WEBBEE_UPGRADED"               # set on the restart after a self-upgrade: never twice in a row
 LIGHT_ENV = "WEBBEE_LIGHT_PYTHON"          # the old Python whose light install runs this release (webbee._launch)
 STEP_TIMEOUT_S = 300
+# one upgrade at a time per user: two webbees started together reinstalled one venv at once and the restart found it
+# half-written (live 2026-10-25: "No module named 'pygments.styles'"); the second waits for the first
+LOCK_WAIT_S = 2 * STEP_TIMEOUT_S + 60
+LOCK_STALE_S = 3 * STEP_TIMEOUT_S
 _WINDOWS = os.name == "nt"
 # `python -c` puts the current folder first on sys.path: a webbee.py there would run in our place (security review).
 # Dropped before any import -- `-I` is no way out, it also drops a `pip install --user` webbee.
@@ -104,14 +109,18 @@ def self_command(version: str, prefix: str = sys.prefix, executable: str = sys.e
     light = env.get(LIGHT_ENV)
     if light:                               # an old Python runs this release through its light install
         return [light, "-m", "pip", "install", "--upgrade", "--no-cache-dir", spec]
-    return _install(tool_of(prefix), spec, uv, pipx, executable)
+    return _install(tool_of(prefix), spec, uv, pipx, executable, venv=DIST)
 
 
-def _install(tool: str, spec: str, uv, pipx, python):
+def _install(tool: str, spec: str, uv, pipx, python, venv: str = ""):
     """``spec`` installed by ``tool`` -- past its index cache: a release minutes old is missing from a cached index page
-    (live 2026-10-25: pip listed nothing newer than 0.5.13 while PyPI served 0.6.0)."""
+    (live 2026-10-25: pip listed nothing newer than 0.5.13 while PyPI served 0.6.0). A pipx venv that exists is upgraded
+    in place (``runpip``): ``install --force`` deletes the venv and builds it again, and a start in that window found
+    it half-written (live 2026-10-25)."""
     if tool == "uv" and uv:
         return [uv, "tool", "install", "--force", "--refresh", spec]
+    if tool == "pipx" and pipx and venv:
+        return [pipx, "runpip", venv, "install", "--upgrade", "--no-cache-dir", spec]
     if tool == "pipx" and pipx:
         return [pipx, "install", "--force", "--pip-args=--no-cache-dir", spec]
     if tool == "pip" and python:
@@ -154,7 +163,7 @@ def mcp_command(inst: dict, newest, uv, pipx, wheel=None):
         return None                         # PyPI unread: what works stays
     spec = _spec(MCP_SPEC, MCP, newest, wheel) if newest else (MCP_SPEC if inst else MCP_GIT_SPEC)
     tool = inst.get("tool") if inst else ("uv" if uv else "pipx" if pipx else "")
-    return _install(tool, spec, uv, pipx, inst.get("python") if inst else None)
+    return _install(tool, spec, uv, pipx, inst.get("python") if inst else None, venv=MCP if inst else "")
 
 
 def restart_command(argv, env=os.environ, executable: str = sys.executable):
@@ -165,6 +174,65 @@ def restart_command(argv, env=os.environ, executable: str = sys.executable):
     return [executable, "-c", _NO_CWD + "from webbee.cli import main; main()", *argv]
 
 
+def _lock_path() -> str:
+    """The lock in webbee's own data folder of this user (0700) -- never a shared temp folder, where anyone could make
+    it first and hold every upgrade back (security review 2026-10-25)."""
+    try:
+        from webbee._launch import _home
+        base = os.path.dirname(_home())
+    except Exception:
+        base = os.path.join(os.path.expanduser("~"), ".webbee")
+    os.makedirs(base, mode=0o700, exist_ok=True)
+    return os.path.join(base, "upgrade.lock")
+
+
+def _lock(path: str) -> bool:
+    """This start's turn to upgrade: the lock file made by it alone (``O_EXCL``, any system); a lock older than any
+    upgrade takes is left over from a killed start and is taken over."""
+    for _ in range(2):
+        try:
+            fd = os.open(path, os.O_CREAT | os.O_EXCL | os.O_WRONLY)
+            os.write(fd, f"{os.getpid()} {time.time():.0f}".encode())
+            os.close(fd)
+            return True
+        except FileExistsError:
+            try:
+                st = os.stat(path)
+                if hasattr(os, "getuid") and st.st_uid != os.getuid():
+                    return True             # not this user's: no lock of ours, the upgrade goes on
+                if time.time() - st.st_mtime < LOCK_STALE_S:
+                    return False
+                os.remove(path)
+            except OSError:
+                return False
+        except OSError:
+            return True                     # no place for a lock: upgrade as before rather than never
+    return False
+
+
+def _unlock(path: str) -> None:
+    try:
+        os.remove(path)
+    except OSError:
+        pass
+
+
+def _wait_unlocked(path: str, sleep=time.sleep) -> None:
+    end = time.time() + LOCK_WAIT_S
+    while os.path.exists(path) and time.time() < end:
+        sleep(1)
+
+
+def imports_ok(python: str, run=subprocess.run) -> bool:
+    """The installed webbee starts: its modules import in its own Python (a half-written venv fails here, not at the
+    user's start)."""
+    try:
+        return run([python, "-c", _NO_CWD + "import webbee.cli, webbee.repl"], capture_output=True, text=True,
+                   timeout=60).returncode == 0
+    except Exception:
+        return False
+
+
 def _run(cmd, run=subprocess.run) -> bool:
     try:
         return run(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.PIPE, text=True,
@@ -174,22 +242,43 @@ def _run(cmd, run=subprocess.run) -> bool:
 
 
 def upgrade_before_start(argv, current: str, say=print, fetch=latest, which=safe_which, run=subprocess.run,
-                         execv=os.execv, env=os.environ, wheel=wheel_url) -> list:
+                         execv=os.execv, env=os.environ, wheel=wheel_url, lock_path=_lock_path,
+                         sleep=time.sleep) -> list:
     """Bring webbee and the shell's imperal-mcp to their newest releases, then let the start go on; a self-upgrade
     starts webbee again on the new release (never returns then). Returns what it did, for the log. Never raises."""
     did: list = []
+    lock = ""
     try:
         if env.get(OFF_ENV) == "1":
             return did
+        lock = lock_path() if lock_path else ""
+        if lock and not _lock(lock):
+            # another webbee is upgrading this install: wait for it, then start on what it installed
+            say("🐝 another webbee is updating -- waiting for it ...")
+            _wait_unlocked(lock, sleep)
+            lock = ""
+            newest = fetch(DIST)
+            if newest and _ver(newest) > _ver(current) and not env.get(DONE_ENV):
+                env[DONE_ENV] = "1"
+                again = restart_command(list(argv), env=env)
+                if _WINDOWS:
+                    sys.exit(subprocess.call(again))
+                execv(again[0], again)
+            return did
         uv, pipx = find_uv(which), which("pipx")
         newest = fetch(DIST)
         if newest and _ver(newest) > _ver(current) and not env.get(DONE_ENV):
             cmd = self_command(newest, env=env, uv=uv, pipx=pipx, wheel=wheel)
             if cmd:
                 say(f"🐝 updating webbee {current} -> {newest} ...")
-                if _run(cmd, run):
+                python = env.get(LIGHT_ENV) or ""
+                ok = _run(cmd, run) and (python or imports_ok(sys.executable, run) or
+                                         (_run(cmd, run) and imports_ok(sys.executable, run)))
+                if ok:
                     did.append(f"webbee {newest}")
                     env[DONE_ENV] = "1"           # the restart inherits it: never a second self-upgrade
+                    _unlock(lock)                 # exec never returns: the lock goes before it, not in finally
+                    lock = ""
                     again = restart_command(list(argv), env=env)
                     if _WINDOWS:            # no exec on Windows: run it and pass its exit code on
                         sys.exit(subprocess.call(again))
@@ -211,5 +300,8 @@ def upgrade_before_start(argv, current: str, say=print, fetch=latest, which=safe
         raise
     except Exception:
         pass
+    finally:
+        if lock:
+            _unlock(lock)
     return did
 

{webbee-0.6.4 → webbee-0.6.6}/tests/test_autoupdate.py

@@ -30,7 +30,7 @@ def test_webbee_upgrades_itself_by_its_own_tool():
     uv = au.self_command("0.6.0", prefix="/u/.local/share/uv/tools/webbee", env={}, uv="/bin/uv")
     assert uv == ["/bin/uv", "tool", "install", "--force", "--refresh", "webbee==0.6.0"]
     px = au.self_command("0.6.0", prefix="/h/.local/pipx/venvs/webbee", env={}, pipx="/bin/pipx")
-    assert px == ["/bin/pipx", "install", "--force", "--pip-args=--no-cache-dir", "webbee==0.6.0"]
+    assert px == ["/bin/pipx", "runpip", "webbee", "install", "--upgrade", "--no-cache-dir", "webbee==0.6.0"]
     pip = au.self_command("0.6.0", prefix="/venv", executable="/venv/bin/python", env={})
     assert pip == ["/venv/bin/python", "-m", "pip", "install", "--upgrade", "--no-cache-dir", "webbee==0.6.0"]
     light = au.self_command("0.6.0", env={au.LIGHT_ENV: "/usr/bin/python3.8"})      # an old Python's light install
@@ -124,3 +124,53 @@ def test_a_release_is_installed_by_its_wheel_s_address_when_pypi_names_it():
     assert got[-1] == f"imperal-mcp[code] @ {mcp_url}"
     assert au.self_command("0.6.1", prefix="/v", executable="/v/bin/python", env={}, wheel=lambda d, v: None)[-1] \
         == "webbee==0.6.1"
+
+
+# ── live 2026-10-25: two starts reinstalled one venv at once; the restart found it half-written ──
+def test_pipx_upgrades_its_venv_in_place():
+    px = au.self_command("0.6.5", prefix="/h/.local/pipx/venvs/webbee", env={}, pipx="/bin/pipx")
+    assert px == ["/bin/pipx", "runpip", "webbee", "install", "--upgrade", "--no-cache-dir", "webbee==0.6.5"]
+    inst = {"tool": "pipx", "python": "/p/bin/python", "version": "0.8.2", "code": True}
+    assert au.mcp_command(inst, "0.8.3", None, "/bin/pipx") == [
+        "/bin/pipx", "runpip", "imperal-mcp", "install", "--upgrade", "--no-cache-dir", "imperal-mcp[code]==0.8.3"]
+    assert au.mcp_command({}, "0.8.3", None, "/bin/pipx")[:3] == ["/bin/pipx", "install", "--force"]   # a new one
+
+
+def test_a_second_start_waits_for_the_first_upgrade_and_starts_on_it(tmp_path):
+    lock = tmp_path / "webbee-upgrade.lock"
+    lock.write_text("1 0")                                    # another webbee is upgrading right now
+    run, execd, env, said = _Run(), [], {}, []
+    slept = []
+
+    def sleep(s):
+        slept.append(s)
+        lock.unlink()                                         # ... and it finishes
+    au.upgrade_before_start(["--once"], "0.6.4", say=said.append, fetch={"webbee": "0.6.5"}.get, wheel=None,
+                            which=_which({"pipx": "/bin/pipx"}), run=run, execv=lambda p, a: execd.append(a),
+                            env=env, lock_path=lambda: str(lock), sleep=sleep)
+    assert run.calls == [] and slept and execd and env[au.DONE_ENV] == "1"   # no second install, the new release
+    assert "another webbee is updating" in said[0]
+
+
+def test_the_lock_is_released_before_the_restart_and_a_broken_install_is_done_again(tmp_path, monkeypatch):
+    lock = tmp_path / "webbee-upgrade.lock"
+    seen = []
+    checks = iter([False, True])                              # the first install left it broken, the second is whole
+    monkeypatch.setattr(au, "imports_ok", lambda python, run=None: next(checks))
+    run = _Run()
+    au.upgrade_before_start([], "0.6.4", say=lambda m: None, fetch={"webbee": "0.6.5"}.get, wheel=None,
+                            which=_which({"pipx": "/bin/pipx"}), run=run, env={}, lock_path=lambda: str(lock),
+                            execv=lambda p, a: seen.append(lock.exists()))
+    assert seen == [False]                                    # no lock left behind by exec
+    assert len([c for c in run.calls if "install" in c]) == 2
+    assert not lock.exists()
+
+
+def test_the_lock_lives_in_webbee_s_own_folder(tmp_path, monkeypatch):
+    monkeypatch.setenv("XDG_DATA_HOME", str(tmp_path / "data"))
+    monkeypatch.delenv("WEBBEE_RUNTIME_HOME", raising=False)
+    path = au._lock_path()
+    assert path.startswith(str(tmp_path / "data")) and path.endswith("upgrade.lock")
+    import os
+    import stat
+    assert stat.S_IMODE(os.stat(os.path.dirname(path)).st_mode) & 0o077 == 0     # only this user

webbee-0.6.4/src/webbee/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.6.4"