webbee 0.6.7__tar.gz → 0.6.9__tar.gz

{webbee-0.6.7 → webbee-0.6.9}/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 0.6.9
+
+* imperal-mcp 0.8.5 at least: a server's repo that cannot be answered says why; parallel code questions never mix
+  their freshness; a change's second-depth users are real ones.
+
+## 0.6.8
+
+* **Autopilot asks nothing**: the coding mode rides every turn, and a switch (Shift-Tab, /mode, a remote flip) reaches
+  the running session at once -- in autopilot the kernel sends no consent request at all, so no turn waits for one.
+  A production release still runs only on your own words.
+* **A server's repo is synced only where it is**: a folder that does not exist, or is in no repository, is refused at
+  once (a wrong path walked `/home` for half an hour), and the repo's HEAD is read in a few small reads.
+* imperal-mcp 0.8.4 at least.
+
 ## 0.6.7
 
 * **The OS's file-watch limit never crashes webbee**: on a large tree (Linux `fs.inotify.max_user_watches`, a repo with

{webbee-0.6.7 → webbee-0.6.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: webbee
-Version: 0.6.7
+Version: 0.6.9
 Summary: Webbee 🐝 — the Imperal Cloud coding agent in your terminal
 Project-URL: Homepage, https://imperal.io
 Project-URL: Documentation, https://docs.imperal.io
@@ -31,7 +31,7 @@ Requires-Python: >=3.7
 Requires-Dist: asyncssh>=2.14; python_version >= '3.10'
 Requires-Dist: httpx-sse>=0.4; python_version >= '3.10'
 Requires-Dist: httpx>=0.27; python_version >= '3.10'
-Requires-Dist: imperal-mcp>=0.8.3; python_version >= '3.10'
+Requires-Dist: imperal-mcp>=0.8.5; python_version >= '3.10'
 Requires-Dist: imperal-sdk>=6.3.6; python_version >= '3.10'
 Requires-Dist: model2vec>=0.8.2; python_version >= '3.10' and (sys_platform != 'darwin' or platform_machine != 'x86_64' or python_version < '3.13')
 Requires-Dist: numpy>=2; python_version >= '3.10' and (sys_platform != 'darwin' or platform_machine != 'x86_64' or python_version < '3.13')

{webbee-0.6.7 → webbee-0.6.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "webbee"
-version = "0.6.7"
+version = "0.6.9"
 description = "Webbee 🐝 — the Imperal Cloud coding agent in your terminal"
 readme = "README.md"
 license = "GPL-3.0-or-later"
@@ -13,7 +13,7 @@ dependencies = [
     # release on a Python 3.12 it sets up once with uv -- `uv` comes as a wheel on 3.8+,
     # 3.7 fetches it with uv's own installer.
     'uv>=0.4; python_version >= "3.8" and python_version < "3.10"',
-    'imperal-mcp>=0.8.3; python_version >= "3.10"',   # raised to the newest at each release
+    'imperal-mcp>=0.8.5; python_version >= "3.10"',   # raised to the newest at each release
     'imperal-sdk>=6.3.6; python_version >= "3.10"',
     'asyncssh>=2.14; python_version >= "3.10"',
     'httpx>=0.27; python_version >= "3.10"',

webbee-0.6.9/src/webbee/__init__.py

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

{webbee-0.6.7 → webbee-0.6.9}/src/webbee/repl.py

@@ -265,10 +265,29 @@ def set_slot_mode(slot: SessionSlot, mode: str) -> None:
     slot.mode = mode
     if slot.agent is not None:
         slot.agent.mode = mode
+        _notify_mode(slot.agent, mode)
     from webbee.mode_store import save_mode
     save_mode(slot.workspace, mode)
 
 
+_MODE_POSTS: set = set()      # in-flight mode notices (a task kept alive until it is done)
+
+
+def _notify_mode(agent, mode: str) -> None:
+    """The running session hears the switch at once (``AgentSession.post_mode``): fire and forget on the running
+    loop; outside a loop (tests, boot) nothing is sent -- the next turn's coding_context carries the mode."""
+    post = getattr(agent, "post_mode", None)
+    if post is None or not getattr(agent, "session_id", ""):
+        return
+    try:
+        loop = asyncio.get_running_loop()
+    except RuntimeError:
+        return
+    task = loop.create_task(post(mode))
+    _MODE_POSTS.add(task)
+    task.add_done_callback(_MODE_POSTS.discard)
+
+
 def set_slot_tier(slot: SessionSlot, tier: str) -> None:
     """The ONE place a slot's model tier is ever assigned (webbee-code-
     model-tier-slash-command-v1) -- mutates `slot.model_tier` + the live

{webbee-0.6.7 → webbee-0.6.9}/src/webbee/session.py

@@ -176,6 +176,21 @@ class AgentSession:
         token = await self.token_provider()
         return {"Authorization": f"Bearer {token}"}
 
+    async def post_mode(self, mode: str) -> bool:
+        """Tell the running session its new coding mode (the gateway signals the kernel's ``set_mode``): autopilot
+        is asked nothing from now on, the others are asked again. False when there is no session yet or no live one
+        took it -- the next turn carries the mode anyway. Never raises."""
+        if not self.session_id or self.cfg is None or self.token_provider is None:
+            return False
+        try:
+            headers = await self._headers()
+            async with make_client(self.cfg, timeout=15) as client:
+                resp = await client.post(f"/v1/agent/sessions/{self.session_id}/mode", json={"mode": mode},
+                                         headers=headers)
+            return resp.status_code == 200 and bool((resp.json() or {}).get("ok"))
+        except Exception:
+            return False
+
     async def run(self, task: str, sink, *, marathon: bool = False, goal: str = "",
                   surface: str = "", steer_iid: str = "") -> str:
         import httpx
@@ -199,6 +214,9 @@ class AgentSession:
         coding_context = await asyncio.to_thread(build_coding_context, self.workspace_root, self._intel)
         if self.model_tier:
             coding_context = {**coding_context, "model_tier": self.model_tier}
+        # the mode this turn runs under: in autopilot the kernel asks no consent at all (no card, no park); a switch
+        # mid-turn reaches the running session through post_mode
+        coding_context = {**coding_context, "mode": str(self.mode or "default")}
         if marathon:
             # verify_cmd is CLIENT-detected here and carried in coding_context —
             # the trusted proof-of-done the kernel runs (never brain-authored).

{webbee-0.6.7 → webbee-0.6.9}/src/webbee/tools.py

@@ -1141,6 +1141,44 @@ async def _open_sftp(host: str):
     return await conn.start_sftp_client(), conn, fps, ""
 
 
+async def _no_repo_at(sftp, ci, root: str) -> str:
+    """Why ``root`` on the server is no repository to sync ("" when it is one): it must exist and be (inside) a
+    repository -- a ``.git`` or a manifest at it or above."""
+    try:
+        await sftp.readdir(root)
+    except Exception as e:
+        return f"{root} does not exist or is not a readable directory ({type(e).__name__})"
+    repo_root = await ci.sftp_repo_root(sftp, root)
+    try:
+        names = {e.filename for e in await sftp.readdir(repo_root)}
+    except Exception:
+        names = set()
+    if not names & (set(getattr(ci, "_REPO_MARKERS", (".git",))) | set(getattr(ci, "_MANIFESTS", ()))):
+        return f"{root} is in no repository (no .git or project manifest at it or above)"
+    return ""
+
+
+async def remote_head(host: str, root: str) -> dict:
+    """The commit the server's repo at ``root`` is on -- a few small SFTP reads (``.git/HEAD`` and its ref), never a
+    listing: ``{"commit", "branch", "root", "why"}``; ``why`` says what failed (an unknown host, a missing folder)."""
+    from imperal_sdk import code_index as ci
+    sftp, conn, _fps, why = await _open_sftp(host)
+    if sftp is None:
+        return {"commit": "", "branch": "", "root": root, "why": f"{host}: {why}"}
+    try:
+        missing = await _no_repo_at(sftp, ci, root)
+        if missing:
+            return {"commit": "", "branch": "", "root": root, "why": f"{host}: {missing}"}
+        repo_root = await ci.sftp_repo_root(sftp, root)
+        ident = ci.git_identity((await ci.sftp_read_meta(sftp, repo_root))["files"])
+        return {"commit": ident.get("commit") or "", "branch": ident.get("branch") or "", "root": repo_root, "why": ""}
+    except Exception as e:
+        return {"commit": "", "branch": "", "root": root, "why": f"{host}: {type(e).__name__}: {e}"}
+    finally:
+        if conn is not None:
+            conn.close()
+
+
 async def remote_sync(client, host: str, root: str, paths: list) -> dict:
     """List and read the repo holding ``root`` on ``host`` over SFTP (the sdk's one walk: .gitignore,
     secrets and dependency trees skipped), extract and embed here, and sync it into the vault through
@@ -1155,6 +1193,10 @@ async def remote_sync(client, host: str, root: str, paths: list) -> dict:
     if sftp is None:
         return {"repo_key": "", "partial_reason": why, "content": f"{host}: {why}"}
     try:
+        missing = await _no_repo_at(sftp, ci, root)
+        if missing:
+            # never a walk of the folder above (live 2026-10-25: a root that did not exist synced /home for 30 min)
+            return {"repo_key": "", "partial_reason": missing, "content": f"{host}: {missing}"}
         repo_root = await ci.sftp_repo_root(sftp, root)
         try:     # the repo's identity is its real path: a symlinked dir names the release it points into
             real_root = str(await sftp.realpath(repo_root) or repo_root) if hasattr(sftp, "realpath") else repo_root

webbee-0.6.9/tests/test_mode_and_remote_0_6_8.py

@@ -0,0 +1,107 @@
+"""0.6.8: the kernel hears the coding mode (autopilot asks nothing -- owner 2026-10-25: "remove the cards, they stall
+her"); a server's repo is synced only where it is (a missing root walked /home for 30 min) and its HEAD is cheap."""
+import asyncio
+from types import SimpleNamespace
+
+import webbee.tools as wt
+
+
+class _Entry:
+    def __init__(self, name):
+        self.filename = name
+
+
+class _Sftp:
+    def __init__(self, tree, files=None):
+        self.tree, self.files = tree, files or {}
+
+    async def readdir(self, path):
+        if path not in self.tree:
+            raise FileNotFoundError(path)
+        return [_Entry(n) for n in self.tree[path]]
+
+
+def test_a_missing_root_is_refused_before_any_walk(monkeypatch):
+    from imperal_sdk import code_index as ci
+    sftp = _Sftp({"/home": ["ipw-repo"], "/": ["home"]})
+    why = asyncio.run(wt._no_repo_at(sftp, ci, "/home/no-such-repo"))
+    assert "does not exist" in why
+
+
+def test_a_folder_in_no_repository_is_refused(monkeypatch):
+    from imperal_sdk import code_index as ci
+    sftp = _Sftp({"/srv/photos": ["a.jpg"], "/srv": ["photos"], "/": ["srv"]})
+    assert "in no repository" in asyncio.run(wt._no_repo_at(sftp, ci, "/srv/photos"))
+    repo = _Sftp({"/r": [".git", "a.py"], "/": ["r"]})
+    assert asyncio.run(wt._no_repo_at(repo, ci, "/r")) == ""
+
+
+def test_remote_sync_of_a_missing_root_says_why_and_lists_nothing(monkeypatch):
+    sftp = _Sftp({"/": ["home"], "/home": []})
+
+    async def opened(host):
+        return sftp, None, [], ""
+    monkeypatch.setattr(wt, "_open_sftp", opened)
+    out = asyncio.run(wt.remote_sync(None, "h", "/home/nope", []))
+    assert out["repo_key"] == "" and "does not exist" in out["partial_reason"]
+
+
+def test_remote_head_reads_the_commit(monkeypatch):
+    from imperal_sdk import code_index as ci
+    sftp = _Sftp({"/r": [".git"], "/": ["r"]})
+
+    async def opened(host):
+        return sftp, None, [], ""
+
+    async def meta(s, root):
+        return {"files": {".git/HEAD": b"ref: refs/heads/master\n", ".git/refs/heads/master": b"fd751713" + b"0" * 32}}
+    monkeypatch.setattr(wt, "_open_sftp", opened)
+    monkeypatch.setattr(ci, "sftp_read_meta", meta)
+    got = asyncio.run(wt.remote_head("h", "/r"))
+    assert got["commit"].startswith("fd751713") and got["branch"] == "master" and got["why"] == ""
+
+    async def unreachable(host):
+        return None, None, [], "OSError: Name or service not known"
+    monkeypatch.setattr(wt, "_open_sftp", unreachable)
+    assert "Name or service not known" in asyncio.run(wt.remote_head("nope", "/r"))["why"]
+
+
+def test_a_mode_switch_reaches_the_running_session(monkeypatch):
+    import webbee.repl as R
+    sent = []
+
+    class _Agent:
+        session_id = "imp_u_a-r1"
+        mode = "default"
+
+        async def post_mode(self, mode):
+            sent.append(mode)
+            return True
+    slot = SimpleNamespace(mode="default", agent=_Agent(), workspace="/w")
+    monkeypatch.setattr("webbee.mode_store.save_mode", lambda ws, m: None)
+
+    async def go():
+        R.set_slot_mode(slot, "autopilot")
+        await asyncio.sleep(0)
+        await asyncio.sleep(0)
+    asyncio.run(go())
+    assert slot.agent.mode == "autopilot" and sent == ["autopilot"]
+
+
+def test_no_session_yet_sends_nothing(monkeypatch):
+    import webbee.repl as R
+
+    class _Agent:
+        session_id = ""
+        mode = "default"
+
+        async def post_mode(self, mode):
+            raise AssertionError("posted without a session")
+    slot = SimpleNamespace(mode="default", agent=_Agent(), workspace="/w")
+    monkeypatch.setattr("webbee.mode_store.save_mode", lambda ws, m: None)
+
+    async def go():
+        R.set_slot_mode(slot, "plan")
+        await asyncio.sleep(0)
+    asyncio.run(go())
+    assert slot.agent.mode == "plan"

webbee-0.6.7/src/webbee/__init__.py

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