webbee 0.5.7__tar.gz → 0.5.9__tar.gz

{webbee-0.5.7 → webbee-0.5.9}/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## 0.5.9
+
+* **Code questions about your local repo go to the exact code graph in your Imperal vault**: on the kernel's request
+  webbee syncs the repo it works in (`intel_sync_local`) and the kernel asks the vault by that repo's key -- who
+  calls what by scope rules, uses inside the same file, tests counted apart. When the vault cannot be reached the
+  old local index answers and says so (`coarse`).
+* **A remote repo is known by its real path** (a symlinked deploy folder is never synced as a second repo), and a
+  code question never waits behind a repo's first sync.
+* **Checkpoints name the paths they changed** -- what imperal-mcp's frame measures an agent's edits by.
+* **Voice**: the recorder stops with its window -- no orphaned ffmpeg filling the disk.
+
+## 0.5.8
+
+* **README**: the supported Python versions (3.7 – 3.14) at the top of the page.
+
 ## 0.5.7
 
 * **The one-time Python 3.12 setup cannot be steered by the folder it starts in**: uv now runs with

{webbee-0.5.7 → webbee-0.5.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: webbee
-Version: 0.5.7
+Version: 0.5.9
 Summary: Webbee 🐝 — the Imperal Cloud coding agent in your terminal
 Project-URL: Homepage, https://imperal.io
 Project-URL: Documentation, https://docs.imperal.io
@@ -56,10 +56,12 @@ Description-Content-Type: text/markdown
 # Webbee 🐝 — The Open-Source ICNLI Coding Agent
 
 [![PyPI](https://img.shields.io/pypi/v/webbee)](https://pypi.org/project/webbee/)
-[![Python](https://img.shields.io/badge/python-3.9%20%7C%203.10%20%7C%203.11%20%7C%203.12%20%7C%203.13%20%7C%203.14-3776ab?logo=python&logoColor=white)](https://pypi.org/project/webbee/)
+[![Python](https://img.shields.io/badge/python-3.7%20%7C%203.8%20%7C%203.9%20%7C%203.10%20%7C%203.11%20%7C%203.12%20%7C%203.13%20%7C%203.14-3776ab?logo=python&logoColor=white)](https://pypi.org/project/webbee/)
 [![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](LICENSE)
 [![Docs](https://img.shields.io/badge/docs-imperal.io-00afd7)](https://docs.imperal.io)
 
+**Python 3.7 – 3.14** · `pip install webbee` works on every one of them.
+
 **Webbee** is the free, open-source terminal coding agent of [Imperal Cloud](https://imperal.io) (the ICNLI AI Cloud OS). It acts directly in your local terminal and workspace: reading, writing, editing, refactoring, and verifying code with deep code intelligence, native multimodal vision, and live cross-platform system capabilities.
 
 Webbee is powered by **ICNLI** (*Infrastructure Contextual Natural Language Interface* — [icnli.org](https://icnli.org)), the open protocol that maps natural-language intent to context-aware infrastructure actions.
@@ -100,8 +102,8 @@ Works with **any Python from 3.7**:
 - **Python 3.7 – 3.9** (macOS ships 3.9, Ubuntu 20.04 has 3.8) — the install is light, and the first
   `webbee` command sets up the same release on its own Python 3.12, once (about 30–45 s, needs internet;
   it fetches uv to do it). Every start after that is immediate, and it is the full webbee — code index
-  and search by meaning included. It lives in `~/.local/share/webbee/runtime`
-  (`%LOCALAPPDATA%\webbee\runtime` on Windows) and changes nothing else on your system.
+  and search by meaning included. It lives in `~/.local/share/webbee/runtime` and changes nothing else on
+  your system.
 
 <details>
 <summary>Install problems</summary>

{webbee-0.5.7 → webbee-0.5.9}/README.md

@@ -1,10 +1,12 @@
 # Webbee 🐝 — The Open-Source ICNLI Coding Agent
 
 [![PyPI](https://img.shields.io/pypi/v/webbee)](https://pypi.org/project/webbee/)
-[![Python](https://img.shields.io/badge/python-3.9%20%7C%203.10%20%7C%203.11%20%7C%203.12%20%7C%203.13%20%7C%203.14-3776ab?logo=python&logoColor=white)](https://pypi.org/project/webbee/)
+[![Python](https://img.shields.io/badge/python-3.7%20%7C%203.8%20%7C%203.9%20%7C%203.10%20%7C%203.11%20%7C%203.12%20%7C%203.13%20%7C%203.14-3776ab?logo=python&logoColor=white)](https://pypi.org/project/webbee/)
 [![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](LICENSE)
 [![Docs](https://img.shields.io/badge/docs-imperal.io-00afd7)](https://docs.imperal.io)
 
+**Python 3.7 – 3.14** · `pip install webbee` works on every one of them.
+
 **Webbee** is the free, open-source terminal coding agent of [Imperal Cloud](https://imperal.io) (the ICNLI AI Cloud OS). It acts directly in your local terminal and workspace: reading, writing, editing, refactoring, and verifying code with deep code intelligence, native multimodal vision, and live cross-platform system capabilities.
 
 Webbee is powered by **ICNLI** (*Infrastructure Contextual Natural Language Interface* — [icnli.org](https://icnli.org)), the open protocol that maps natural-language intent to context-aware infrastructure actions.
@@ -45,8 +47,8 @@ Works with **any Python from 3.7**:
 - **Python 3.7 – 3.9** (macOS ships 3.9, Ubuntu 20.04 has 3.8) — the install is light, and the first
   `webbee` command sets up the same release on its own Python 3.12, once (about 30–45 s, needs internet;
   it fetches uv to do it). Every start after that is immediate, and it is the full webbee — code index
-  and search by meaning included. It lives in `~/.local/share/webbee/runtime`
-  (`%LOCALAPPDATA%\webbee\runtime` on Windows) and changes nothing else on your system.
+  and search by meaning included. It lives in `~/.local/share/webbee/runtime` and changes nothing else on
+  your system.
 
 <details>
 <summary>Install problems</summary>

{webbee-0.5.7 → webbee-0.5.9}/pyproject.toml

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

webbee-0.5.9/src/webbee/__init__.py

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

{webbee-0.5.7 → webbee-0.5.9}/src/webbee/checkpoints.py

@@ -107,7 +107,8 @@ class ShadowGit:
 
     def checkpoint(self, label: str = "", force: bool = False) -> "dict | None":
         """Commit the workspace state to the shadow history.
-        {"id","n","label","changed"} or None when unavailable/failed.
+        {"id","n","label","changed","paths"} or None when unavailable/failed --
+        ``paths``: the workspace paths this snapshot changed (sorted; [] when none).
         `force=True` always records a new checkpoint even with nothing dirty
         -- used by rollback() for its mandatory pre-rollback safety snapshot,
         which must exist even when the workspace already matches HEAD."""
@@ -117,10 +118,11 @@ class ShadowGit:
             if self._git("add", "-A").returncode != 0:
                 return None          # a partial add must never masquerade as a snapshot
             dirty = self._git("status", "--porcelain").stdout.strip()
+            paths = sorted({ln[3:].split(" -> ")[-1].strip().strip('"') for ln in dirty.splitlines() if len(ln) > 3})
             head = self._git("rev-parse", "--short", "HEAD")
             if not dirty and head.returncode == 0 and not force:
                 return {"id": head.stdout.strip(), "n": self._count(),
-                        "label": "(no changes)", "changed": False}
+                        "label": "(no changes)", "changed": False, "paths": []}
             msg = (label or "checkpoint").strip()[:200] or "checkpoint"
             args = ["commit", "-m", msg, "--no-verify"]
             if head.returncode != 0 or not dirty:
@@ -131,7 +133,7 @@ class ShadowGit:
             sha = self._git("rev-parse", "--short", "HEAD").stdout.strip()
             n = self._count() + 1
             self._git("update-ref", f"refs/webbee/cp-{n}", "HEAD")
-            return {"id": sha, "n": n, "label": msg, "changed": True}
+            return {"id": sha, "n": n, "label": msg, "changed": True, "paths": paths}
         except Exception:
             return None
 

{webbee-0.5.7 → webbee-0.5.9}/src/webbee/consent.py

@@ -13,7 +13,7 @@ from webbee.frames import _is_foreign_frame, render_foreign_frame
 # Verbs that only read: the kernel never asks consent for them (a verified read, core.action_effect); a
 # confirm_request naming one is answered yes here without a prompt (code graph spec §4.8: index reads
 # never ask -- intel_sync_remote lists and reads a repo over SFTP, writes nothing, runs nothing there).
-READ_VERBS = frozenset({"intel_sync_remote"})
+READ_VERBS = frozenset({"intel_sync_remote", "intel_sync_local"})
 
 
 async def handle_confirm_request(frame: dict, mode: str, ask_consent) -> dict:

{webbee-0.5.7 → webbee-0.5.9}/src/webbee/intel/service.py

@@ -278,7 +278,7 @@ class IntelService:
                 if fresh_ids:
                     self.vectors.add(fresh_ids, fresh_vecs)
 
-    def _sync_vault(self, rels=None) -> dict:
+    def _sync_vault(self, rels=None, history: bool = True) -> dict:
         """The workspace (``rels=None``: every indexable file, with the git history's co-change links) or the
         changed files into the vault. Fail-soft: a cloud outage never touches the local index."""
         factory = self.vault_client_factory
@@ -309,7 +309,7 @@ class IntelService:
                         "machine_kind": "local", "git": local_git_identity(self.root),
                         "local_key": compute_repo_key(self.root), "listing_complete": rels is None}
                 listing = _local_listing(self.root, rels)
-                measured = co_change_pairs(self.root) if rels is None else None
+                measured = co_change_pairs(self.root) if rels is None and history else None
                 out = asyncio.run(vault_sync(factory(), meta, listing, read, measured))
             except Exception as exc:
                 log.warning("code sync to the vault failed: %s", exc)
@@ -323,6 +323,22 @@ class IntelService:
             return out
 
 
+    def sync_now(self) -> dict:
+        """The kernel asks before a code question (frame phase A): the workspace reaches the vault now -- a full
+        listing, so an edit no watcher reported (a shell edit) is sent too; the vault's plan picks the changed files.
+        The git history is not re-read. ``{repo_key, synced_at, ...counts}`` or ``{ok: False, content}``."""
+        if self.vault_client_factory is None:
+            return {"ok": False, "content": "this session cannot reach the cloud"}
+        if not self.last_sync and not self._sync_lock.acquire(blocking=False):
+            # the repo's first sync (a whole repo: extract + embed) is still running: never wait behind it
+            return {"ok": False, "content": "the first code sync of this repo is still running"}
+        if not self.last_sync:
+            self._sync_lock.release()
+        out = self._sync_vault(None, history=False)
+        if not out.get("repo_key"):
+            return {"ok": False, "content": "the code sync to the vault failed"}
+        return {**out, "synced_at": time.time()}
+
     def sync_vault(self, rels=None) -> None:
         """Off the caller's thread: the build and the watcher never wait for the cloud."""
         if self.vault_client_factory is None:

{webbee-0.5.7 → webbee-0.5.9}/src/webbee/modals.py

@@ -10,6 +10,7 @@ Enterprise Grade Multi-OS popups with:
 """
 from __future__ import annotations
 
+import atexit
 import itertools
 import os
 import re
@@ -223,18 +224,56 @@ def get_macos_builtin_audio_device() -> str:
         return ":0"
 
 
+# A voice note never outlives this, even if every stop path fails: ffmpeg ends itself (-t).
+MAX_VOICE_NOTE_SECONDS = 900
+
+
 def get_system_audio_capture_args(output_path: str) -> List[str]:
-    """Build cross-platform FFmpeg audio recording CLI arguments for macOS, Linux, and Windows."""
+    """Build cross-platform FFmpeg audio recording CLI arguments for macOS, Linux, and Windows.
+
+    -nostdin: ffmpeg never reads the terminal (the TUI owns the keys); -t caps the length."""
     if sys.platform == "darwin":
         dev = get_macos_builtin_audio_device()
-        return ["ffmpeg", "-y", "-f", "avfoundation", "-i", dev, "-ar", "16000", "-ac", "1", output_path]
+        src = ["-f", "avfoundation", "-i", dev, "-ar", "16000", "-ac", "1"]
     elif sys.platform.startswith("linux"):
         if shutil.which("pactl"):
-            return ["ffmpeg", "-y", "-f", "pulse", "-i", "default", "-ar", "16000", "-ac", "1", output_path]
-        return ["ffmpeg", "-y", "-f", "alsa", "-i", "default", "-ar", "16000", "-ac", "1", output_path]
+            src = ["-f", "pulse", "-i", "default", "-ar", "16000", "-ac", "1"]
+        else:
+            src = ["-f", "alsa", "-i", "default", "-ar", "16000", "-ac", "1"]
     elif sys.platform in ("win32", "cygwin"):
-        return ["ffmpeg", "-y", "-f", "dshow", "-i", "audio=virtual-audio-device", "-ar", "16000", "-ac", "1", output_path]
-    return ["ffmpeg", "-y", "-i", "default", output_path]
+        src = ["-f", "dshow", "-i", "audio=virtual-audio-device", "-ar", "16000", "-ac", "1"]
+    else:
+        src = ["-i", "default"]
+    return ["ffmpeg", "-nostdin", "-y", *src, "-t", str(MAX_VOICE_NOTE_SECONDS), output_path]
+
+
+# Every recorder still running; atexit stops them so a quit Webbee leaves no microphone open.
+_LIVE_RECORDERS: set = set()
+
+
+def stop_recorder(proc: Optional[subprocess.Popen]) -> None:
+    """Stop one ffmpeg recorder: SIGTERM (ffmpeg finalizes the file), SIGKILL if it hangs."""
+    if proc is None:
+        return
+    _LIVE_RECORDERS.discard(proc)
+    try:
+        if proc.poll() is None:
+            proc.terminate()
+            try:
+                proc.wait(timeout=2)
+            except subprocess.TimeoutExpired:
+                proc.kill()
+                proc.wait(timeout=2)
+    except Exception:
+        pass
+
+
+def stop_all_recorders() -> None:
+    for proc in list(_LIVE_RECORDERS):
+        stop_recorder(proc)
+
+
+atexit.register(stop_all_recorders)
 
 
 def transcribe_audio_file(audio_path: str, api_url: str = "", token: str = "") -> str:
@@ -397,10 +436,13 @@ def create_mic_dialog(
     voice_path = os.path.join(voice_dir, voice_filename)
 
     rec_proc: Optional[subprocess.Popen] = None
+    sent = False
 
     try:
         args = get_system_audio_capture_args(voice_path)
-        rec_proc = subprocess.Popen(args, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        rec_proc = subprocess.Popen(args, stdin=subprocess.DEVNULL,
+                                    stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        _LIVE_RECORDERS.add(rec_proc)
     except Exception:
         pass
 
@@ -417,18 +459,13 @@ def create_mic_dialog(
     anim_ctrl = FormattedTextControl(_anim_text)
 
     def _stop_rec() -> int:
-        nonlocal rec_proc
         elapsed = max(1, int(time.time() - start_time))
-        if rec_proc is not None:
-            try:
-                if rec_proc.poll() is None:
-                    rec_proc.terminate()
-                    rec_proc.wait(timeout=2)
-            except Exception:
-                pass
+        stop_recorder(rec_proc)
         return elapsed
 
     def _handle_send():
+        nonlocal sent
+        sent = True
         rec_seconds = _stop_rec()
         on_close()
 
@@ -481,13 +518,18 @@ def create_mic_dialog(
         t = threading.Thread(target=_worker, daemon=True)
         t.start()
 
-    def _handle_cancel():
+    def _discard():
+        if sent:
+            return
         _stop_rec()
         try:
             if os.path.exists(voice_path):
                 os.remove(voice_path)
         except Exception:
             pass
+
+    def _handle_cancel():
+        _discard()
         on_close()
 
     # EXACTLY TWO BUTTONS: Send and Cancel matching all other dialog layouts
@@ -505,13 +547,17 @@ def create_mic_dialog(
     cols = app.output.get_size()[1] if (app and app.output) else 80
     dialog_width = Dimension(min=36, max=76, preferred=min(68, max(36, cols - 6)))
 
-    return Dialog(
+    dialog = Dialog(
         title="Voice Recording (STT)",
         body=HSplit(all_elements),
         buttons=[],
         width=dialog_width,
         modal=True,
     )
+    # The host calls dispose() whenever the dialog goes away (Esc, another modal) -- not only
+    # via the two buttons -- so the microphone is never left recording.
+    dialog.dispose = _discard
+    return dialog
 
 
 def create_session_menu_dialog(

{webbee-0.5.7 → webbee-0.5.9}/src/webbee/tools.py

@@ -768,6 +768,24 @@ class LocalToolExecutor:
         return []
 
     def _cpc(self, verb: str, a: dict) -> dict:
+        out = self._cpc_local(verb, a)
+        # frame phase A: the kernel asks the vault graph first; this local index is the fallback -- links by name
+        if isinstance(out, dict) and out.get("ok", True) is not False:
+            out = {**out, "coarse": "vault graph unavailable: links by name"}
+        return out
+
+    def _t_intel_sync_local(self, a: dict) -> dict:
+        """The workspace into the vault's code graph now (frame phase A): the kernel asks before a local code
+        question when the vault's copy is behind the last edit. A read: nothing is written or run."""
+        if self.indexer is None or not hasattr(self.indexer, "sync_now"):
+            return {"ok": False, "content": "intel_sync_local: no code index in this session"}
+        out = self.indexer.sync_now()
+        if out.get("ok") is False:
+            return {"ok": False, "content": f"intel_sync_local: {out.get('content')}"}
+        counts = {k: v for k, v in out.items() if k not in ("repo_key", "synced_at")}
+        return {"ok": True, "content": {"repo_key": out["repo_key"], "synced_at": out["synced_at"], "counts": counts}}
+
+    def _cpc_local(self, verb: str, a: dict) -> dict:
         if self.indexer is None:
             return {"ok": False, "content": "intel not available; install webbee[intel]"}
         from webbee.intel import query
@@ -1136,6 +1154,10 @@ async def remote_sync(client, host: str, root: str, paths: list) -> dict:
         return {"repo_key": "", "partial_reason": why, "content": f"{host}: {why}"}
     try:
         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
+        except Exception:
+            real_root = repo_root
         meta_files = (await ci.sftp_read_meta(sftp, repo_root))["files"]
         if paths:
             listing = []
@@ -1154,7 +1176,7 @@ async def remote_sync(client, host: str, root: str, paths: list) -> dict:
         meta = {"machine": {"fingerprints": fps,
                             "machine_id": meta_files.get("/etc/machine-id", b"").decode("utf-8", "replace").strip(),
                             "label": host},
-                "root": repo_root, "root_path": repo_root, "os": tree["os"], "source": "system_ssh", "ref": host,
+                "root": real_root, "root_path": real_root, "os": tree["os"], "source": "system_ssh", "ref": host,
                 "machine_kind": "ssh", "git": ci.git_identity(meta_files), "listing_complete": not paths}
         if tree.get("partial"):
             meta["partial_listing"] = tree["partial"]

{webbee-0.5.7 → webbee-0.5.9}/src/webbee/tui.py

@@ -1886,7 +1886,19 @@ async def run_session(*, slots, on_line, on_cycle, on_tier_cycle=None,
         if app is not None:
             app.invalidate()
 
+    def _dispose_modal(dialog):
+        # A dialog that holds a resource (the mic recorder) releases it however it is closed.
+        dispose = getattr(dialog, "dispose", None)
+        if callable(dispose):
+            try:
+                dispose()
+            except Exception:
+                pass
+
     def _set_modal_active(dialog):
+        prev = _active_modal.get("dialog")
+        if prev is not None and prev is not dialog:
+            _dispose_modal(prev)
         _active_modal["dialog"] = dialog
         from prompt_toolkit.application import get_app_or_none
         app = get_app_or_none()
@@ -1900,7 +1912,10 @@ async def run_session(*, slots, on_line, on_cycle, on_tier_cycle=None,
         _invalidate()
 
     def _close_modal():
+        prev = _active_modal.get("dialog")
         _active_modal["dialog"] = None
+        if prev is not None:
+            _dispose_modal(prev)
         _hover_on["v"] = None
         # Guarantee buffer is 100% clean of any mouse escape residue on modal close
         buf.text = scrub_mouse_residue(buf.text)

{webbee-0.5.7 → webbee-0.5.9}/tests/test_checkpoints.py

@@ -276,3 +276,17 @@ def test_describe_surfaces_paused_autocheckpoint(tmp_path):
     out = sg.describe()
     assert out.startswith("⚠ Auto-checkpointing is paused")
     assert "cp-1" in out                # the list still follows the warning
+
+
+def test_checkpoint_names_the_changed_paths(tmp_path):
+    """Phase B Task 10: a snapshot says which paths it changed (imperal-mcp measures an agent's edits by it)."""
+    from webbee.checkpoints import ShadowGit
+    ws = tmp_path / "ws"
+    ws.mkdir()
+    (ws / "a.py").write_text("x=1\n")
+    sg = ShadowGit(str(ws), "k", cache_dir=str(tmp_path / "c"))
+    assert sg.ensure()
+    assert sg.checkpoint("base", force=True)["paths"] == ["a.py"]
+    (ws / "a.py").write_text("x=2\n")
+    assert sg.checkpoint("next")["paths"] == ["a.py"]
+    assert sg.checkpoint("same")["paths"] == []

{webbee-0.5.7 → webbee-0.5.9}/tests/test_intel_service.py

@@ -287,3 +287,42 @@ def test_a_link_leading_out_of_the_workspace_is_never_read(tmp_path, monkeypatch
     sent = [c[1] for c in cloud.calls if "files" in c[1]]
     assert sent and all(f["path"] != "leak.py" for c in sent for f in c["files"])
     assert "outside the workspace" not in repr(cloud.calls)
+
+
+def test_sync_now_sends_an_edit_the_watcher_has_not_reported(tmp_path, monkeypatch):
+    """frame phase A: the kernel asks for a sync before a code question -- the edit reaches the vault at once,
+    even one no watcher reported (a shell edit), and without re-reading the git history."""
+    (tmp_path / "a.py").write_text("def alpha():\n    return 1\n")
+    svc = IntelService(str(tmp_path), "rk", cache_dir=str(tmp_path / "c"))
+    _synced(svc, monkeypatch)
+    cloud = _Cloud()
+    svc.build()
+    svc.attach_vault(lambda: cloud)
+    cloud.calls.clear()
+    cloud.have = {"a.py"}
+    (tmp_path / "b.py").write_text("def beta():\n    return 2\n")          # a shell edit, never reported
+    out = svc.sync_now()
+    assert out["repo_key"] and out["synced_at"] > 0
+    assert [f["path"] for f in cloud.calls[1][1]["files"]] == ["b.py"]
+    assert "measured" not in cloud.calls[1][1]
+
+
+def test_sync_now_without_cloud_says_so(tmp_path):
+    svc = IntelService(str(tmp_path), "rk", cache_dir=str(tmp_path / "c"))
+    assert svc.sync_now() == {"ok": False, "content": "this session cannot reach the cloud"}
+
+
+def test_sync_now_while_the_first_sync_runs_answers_at_once(tmp_path, monkeypatch):
+    """frame phase A (review I7): a big repo's first sync is still running -- the question goes coarse at once
+    instead of waiting behind it."""
+    (tmp_path / "a.py").write_text("def alpha():\n    return 1\n")
+    svc = IntelService(str(tmp_path), "rk", cache_dir=str(tmp_path / "c"))
+    svc.build()
+    svc.vault_client_factory = lambda: _Cloud()
+    svc.last_sync = {}
+    assert svc._sync_lock.acquire(blocking=False)          # the boot-time first sync holds the lock
+    try:
+        out = svc.sync_now()
+    finally:
+        svc._sync_lock.release()
+    assert out == {"ok": False, "content": "the first code sync of this repo is still running"}

{webbee-0.5.7 → webbee-0.5.9}/tests/test_modals_e2e.py

@@ -73,7 +73,46 @@ def test_file_picker_dialog_callbacks():
     assert dialog.title == "Attach File / Document"
 
 
-def test_mic_dialog_callbacks():
+class _FakeRecorder:
+    """Stands in for the ffmpeg Popen -- tests never open the real microphone."""
+    def __init__(self, args, **kw):
+        self.args, self.kw = args, kw
+        self.alive = True
+        self.signals = []
+        with open(args[-1], "wb") as f:
+            f.write(b"RIFF")
+
+    def poll(self):
+        return None if self.alive else 0
+
+    def terminate(self):
+        self.signals.append("TERM")
+        self.alive = False
+
+    def kill(self):
+        self.signals.append("KILL")
+        self.alive = False
+
+    def wait(self, timeout=None):
+        return 0
+
+
+@pytest.fixture
+def fake_recorder(monkeypatch, tmp_path):
+    import webbee.modals as m
+    made = []
+
+    def _popen(args, **kw):
+        made.append(_FakeRecorder(args, **kw))
+        return made[-1]
+
+    monkeypatch.setattr(m.subprocess, "Popen", _popen)
+    monkeypatch.setattr(m, "get_macos_builtin_audio_device", lambda: ":0")
+    return made, str(tmp_path)
+
+
+def test_mic_dialog_callbacks(fake_recorder):
+    _, voice_dir = fake_recorder
     transcribed = []
     sent = []
     closed = []
@@ -82,8 +121,80 @@ def test_mic_dialog_callbacks():
         on_transcribe=lambda t: transcribed.append(t),
         on_send_direct=lambda t: sent.append(t),
         on_close=lambda: closed.append(True),
+        voice_dir=voice_dir,
     )
     assert dialog.title == "Voice Recording (STT)"
+    dialog.dispose()
+
+
+def test_mic_dialog_dispose_stops_recording_and_drops_the_file(fake_recorder):
+    # Esc / another modal closes the dialog through dispose(), not the buttons:
+    # the recorder must stop and the unsent audio must go.
+    made, voice_dir = fake_recorder
+    dialog = create_mic_dialog(on_transcribe=lambda t: None, on_send_direct=lambda t: None,
+                               on_close=lambda: None, voice_dir=voice_dir)
+    rec = made[0]
+    assert rec.kw.get("stdin") is not None          # never the terminal's stdin
+    dialog.dispose()
+    assert rec.signals == ["TERM"] and not rec.alive
+    assert os.listdir(voice_dir) == []
+    dialog.dispose()                                # idempotent
+    assert rec.signals == ["TERM"]
+
+
+def test_stop_recorder_kills_a_recorder_that_ignores_term():
+    import subprocess
+    from webbee.modals import stop_recorder
+
+    class _Stuck(_FakeRecorder):
+        def __init__(self):
+            self.alive, self.signals = True, []
+
+        def terminate(self):
+            self.signals.append("TERM")              # ignored
+
+        def wait(self, timeout=None):
+            if self.alive:
+                raise subprocess.TimeoutExpired("ffmpeg", timeout)
+            return 0
+
+    p = _Stuck()
+    stop_recorder(p)
+    assert p.signals == ["TERM", "KILL"] and not p.alive
+
+
+def test_quitting_stops_every_live_recorder(fake_recorder):
+    import webbee.modals as m
+    made, voice_dir = fake_recorder
+    create_mic_dialog(on_transcribe=lambda t: None, on_send_direct=lambda t: None,
+                      on_close=lambda: None, voice_dir=voice_dir)
+    assert made[0] in m._LIVE_RECORDERS
+    m.stop_all_recorders()                          # what atexit runs
+    assert not made[0].alive and not m._LIVE_RECORDERS
+
+
+def test_mic_send_keeps_the_audio_for_transcription(fake_recorder, monkeypatch):
+    import webbee.modals as m
+    made, voice_dir = fake_recorder
+    seen = []
+    monkeypatch.setattr(m, "transcribe_audio_file",
+                        lambda path, **kw: seen.append(os.path.exists(path)) or "hello")
+    buttons = {}
+    real_button = m.make_clean_button
+    monkeypatch.setattr(m, "make_clean_button",
+                        lambda text, handler=None, **kw: buttons.setdefault(text, handler) and real_button(text, handler=handler, **kw))
+    host = {}
+    dialog = create_mic_dialog(on_transcribe=lambda t: None, on_send_direct=lambda t: None,
+                               on_close=lambda: host["dialog"].dispose(), voice_dir=voice_dir)
+    host["dialog"] = dialog
+    buttons["▶ Send Voice Note"]()
+    import time
+    for _ in range(50):
+        if seen:
+            break
+        time.sleep(0.02)
+    assert seen == [True]                           # host's dispose on close did not delete it
+    assert not made[0].alive
 
 
 def test_session_menu_dialog_callbacks():
@@ -122,6 +233,8 @@ def test_system_audio_capture_args():
     assert len(cmd) > 0
     assert cmd[0] == "ffmpeg"
     assert "/tmp/test_out.wav" in cmd
+    assert "-nostdin" in cmd
+    assert cmd[cmd.index("-t") + 1] == "900"
 
 
 def test_modal_input_insulation_prevents_command_line_pollution():

{webbee-0.5.7 → webbee-0.5.9}/tests/test_tools.py

@@ -923,3 +923,40 @@ def test_an_asyncssh_connect_reports_every_key_of_the_host_the_user_trusts(monke
     monkeypatch.setattr(asyncssh, "connect", connect)
     sftp, conn, fps, why = asyncio.run(t._open_sftp("whm-jump"))
     assert sftp == "sftp" and why == "" and fps == ["SHA256:ecdsa", "SHA256:ed", "SHA256:rsa"]
+
+
+def test_intel_sync_local_returns_the_vault_key(tmp_path):
+    class _Svc:
+        def sync_now(self):
+            return {"repo_key": "rk1", "synced_at": 5.0, "files": 1}
+    ex = LocalToolExecutor(str(tmp_path), indexer=_Svc())
+    out = ex._t_intel_sync_local({"root": str(tmp_path)})
+    assert out == {"ok": True, "content": {"repo_key": "rk1", "synced_at": 5.0, "counts": {"files": 1}}}
+
+
+def test_local_code_answers_marked_coarse(tmp_path):
+    from webbee.intel.service import IntelService
+    (tmp_path / "a.py").write_text("def alpha():\n    return 1\n")
+    svc = IntelService(str(tmp_path), "rk", cache_dir=str(tmp_path / "c"))
+    svc.build()
+    ex = LocalToolExecutor(str(tmp_path), indexer=svc)
+    out = ex._t_impact_of_change({"symbols": ["alpha"], "_local_index": True})
+    assert out["coarse"] == "vault graph unavailable: links by name"
+
+
+def test_intel_sync_local_needs_no_consent():
+    from webbee.consent import READ_VERBS
+    assert "intel_sync_local" in READ_VERBS
+
+
+def test_a_symlinked_remote_repo_is_known_by_its_real_path(monkeypatch):
+    """frame phase A (review I2): the repo's identity is the real path the server reports."""
+    sftp = _Sftp(WIN_TREE, WIN_FILES)
+
+    async def realpath(p):
+        return "/C:/real/proj" if p == "/C:/u/proj" else p
+    sftp.realpath = realpath
+    ex, cloud = _remote(monkeypatch, sftp)
+    ex.run("intel_sync_remote", {"host": "winbox", "root": "/C:/u/proj/Pkg"})
+    meta = cloud.calls[0][1]["meta"]
+    assert meta["root"] == meta["root_path"] == "/C:/real/proj"

webbee-0.5.7/src/webbee/__init__.py

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