webbee 0.5.2__tar.gz → 0.5.3__tar.gz

{webbee-0.5.2 → webbee-0.5.3}/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## 0.5.3
+
+* **grep finds lines in a single file**: a grep whose path is one file searched nothing and answered
+  "(no matches)" -- the agent concluded things were missing that were there.
+* **The connection survives sleep and network changes**: sockets carry TCP keepalive (a connection that died
+  while the laptop slept is found dead in about a minute instead of hanging the stream), idle pooled
+  connections expire after 30s, and the stream reconnects at once after a wake.
+* **The tab bar never vanishes**: it is one fixed row that never wraps or scrolls; a broken terminal size
+  falls back to sane bounds.
+* **A UI that fails to start says why** on the real terminal, not only in `/tmp/dock_boot_error.log`.
+
 ## 0.5.2
 
 * **One server, one machine**: a repo synced over your own `ssh` reports every host key of that server your

{webbee-0.5.2 → webbee-0.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: webbee
-Version: 0.5.2
+Version: 0.5.3
 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.5.2 → webbee-0.5.3}/pyproject.toml

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

webbee-0.5.3/src/webbee/__init__.py

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

webbee-0.5.3/src/webbee/http.py

@@ -0,0 +1,64 @@
+"""ONE keep-alive httpx.AsyncClient for the client's small gateway calls.
+Before W1 the idle-steer poller opened a NEW AsyncClient — a fresh TCP+TLS
+handshake — every 4s tick, forever (thread.py per-call clients). The repl owns
+one client for the loop's lifetime and passes it down; every callee keeps a
+per-call fallback so tests and old call sites work unchanged.
+
+Sleep and network changes: the sockets carry TCP keepalive, so a connection
+that died while the laptop slept is found dead within about a minute instead of
+hanging a stream forever; idle pooled connections expire after 30s, so the next
+call after a wake opens a fresh one. ``WakeDetector`` tells a reconnect loop the
+machine slept, so it reconnects at once instead of waiting out its backoff."""
+from __future__ import annotations
+
+import socket
+import time
+
+# keepalive probes: first after 30s idle, then every 10s, dead after 3 misses
+_KEEPIDLE_S, _KEEPINTVL_S, _KEEPCNT = 30, 10, 3
+_SLEEP_GAP_S = 8.0
+
+
+class WakeDetector:
+    """Did the machine sleep since the last ``check()``? The wall clock keeps running while a laptop
+    sleeps and the monotonic clock does not (Linux, macOS), so their drift is the time asleep. A long
+    idle wait is never a sleep: both clocks move together. One instance per loop -- never shared."""
+
+    def __init__(self, gap_s: float = _SLEEP_GAP_S, *, wall=time.time, mono=time.monotonic):
+        self._gap, self._wall, self._mono = float(gap_s), wall, mono
+        self._w, self._m = wall(), mono()
+
+    def check(self) -> bool:
+        w, m = self._wall(), self._mono()
+        slept = (w - self._w) - (m - self._m) > self._gap
+        self._w, self._m = w, m
+        return slept
+
+
+def socket_options() -> list:
+    """TCP keepalive options this OS supports (Linux: TCP_KEEPIDLE; macOS: TCP_KEEPALIVE)."""
+    opts = []
+    if hasattr(socket, "SO_KEEPALIVE"):
+        opts.append((socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1))
+    for idle in ("TCP_KEEPIDLE", "TCP_KEEPALIVE"):
+        if hasattr(socket, idle):
+            opts.append((socket.IPPROTO_TCP, getattr(socket, idle), _KEEPIDLE_S))
+            break
+    if hasattr(socket, "TCP_KEEPINTVL"):
+        opts.append((socket.IPPROTO_TCP, socket.TCP_KEEPINTVL, _KEEPINTVL_S))
+    if hasattr(socket, "TCP_KEEPCNT"):
+        opts.append((socket.IPPROTO_TCP, socket.TCP_KEEPCNT, _KEEPCNT))
+    return opts
+
+
+def build_transport(retries: int = 1):
+    """An AsyncHTTPTransport with TCP keepalive and a short idle expiry (``retries``: connect retries)."""
+    import httpx
+    return httpx.AsyncHTTPTransport(
+        retries=retries, socket_options=socket_options(),
+        limits=httpx.Limits(max_keepalive_connections=20, max_connections=50, keepalive_expiry=30.0))
+
+
+def make_client(cfg, timeout: float = 10.0):
+    import httpx
+    return httpx.AsyncClient(base_url=cfg.api_url, timeout=timeout, transport=build_transport())

{webbee-0.5.2 → webbee-0.5.3}/src/webbee/repl.py

@@ -1737,6 +1737,7 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
         # log; the contextlib redirect below additionally covers Python-level
         # sys.stderr writers. Fail-soft: on any failure leave fd 2 untouched.
         _saved_stderr_fd = None
+        _boot_error = ""
         try:
             _saved_stderr_fd = os.dup(2)
             os.dup2(_errlog.fileno(), 2)
@@ -1993,6 +1994,7 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
             import traceback
             with open("/tmp/dock_boot_error.log", "w") as f:
                 traceback.print_exc(file=f)
+            _boot_error = f"{type(e).__name__}: {e}"
             ok = False
         finally:
             # Restore the real fd 2 BEFORE the transcript dump / any later
@@ -2007,6 +2009,10 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
                 _errlog.close()
             except Exception:
                 pass
+            if _boot_error:     # said on the REAL stderr (fd 2 is restored): never a silent fallback
+                sys.stderr.write(f"\r\n[webbee] the terminal UI failed to start: {_boot_error[:300]}\r\n"
+                                 "         details: /tmp/dock_boot_error.log\r\n")
+                sys.stderr.flush()
         if ok:
             # the alt screen is gone — reprint EVERY session tab's own
             # scrollback to real stdout (Task 7: was just the one slot that

{webbee-0.5.2 → webbee-0.5.3}/src/webbee/session.py

@@ -3,6 +3,7 @@ import time
 from collections import OrderedDict, deque
 
 from webbee.coding_context import build_coding_context, detect_verify_cmd
+from webbee.http import make_client
 from webbee.consent import _retire, race_consent
 from webbee.frames import (
     _MARATHON_FACT_TYPES,
@@ -232,7 +233,7 @@ class AgentSession:
             body["goal"] = goal
 
         headers = await self._headers()
-        async with httpx.AsyncClient(base_url=self.cfg.api_url, timeout=60) as client:
+        async with make_client(self.cfg, timeout=60) as client:     # keepalive: a slept socket dies, never hangs
             resp = await _transient_retry(lambda: client.post(
                 "/v1/agent/sessions", json=body, headers=headers))
             resp.raise_for_status()
@@ -274,7 +275,7 @@ class AgentSession:
         executor = LocalToolExecutor(self.workspace_root, indexer=self._intel,
                                      shadow=self._shadow,
                                      client_factory=self._file_client_factory())
-        async with httpx.AsyncClient(base_url=self.cfg.api_url, timeout=60) as client:
+        async with make_client(self.cfg, timeout=60) as client:     # keepalive: a slept socket dies, never hangs
             return await self._serve_stream(sink, client, session_id, start_id, task_id,
                                             executor, marathon=marathon)
 

{webbee-0.5.2 → webbee-0.5.3}/src/webbee/sizing.py

@@ -12,12 +12,20 @@ def get_size(app=None) -> tuple[int, int]:
     if out is not None and hasattr(out, "get_size"):
         try:
             s = out.get_size()
-            return int(s.columns), int(s.rows)
+            cols = int(getattr(s, "columns", 0))
+            rows = int(getattr(s, "rows", 0))
+            if cols > 0 and rows > 0:
+                return max(40, cols), max(10, rows)
         except Exception:
             pass
     import shutil
-    s = shutil.get_terminal_size((100, 24))
-    return int(s.columns), int(getattr(s, "lines", 24))
+    try:
+        s = shutil.get_terminal_size((100, 24))
+        cols = int(getattr(s, "columns", 100))
+        rows = int(getattr(s, "lines", 24))
+        return max(40, cols if cols > 0 else 100), max(10, rows if rows > 0 else 24)
+    except Exception:
+        return 100, 24
 
 
 def input_height_cap(rows: int) -> int:

{webbee-0.5.2 → webbee-0.5.3}/src/webbee/stream.py

@@ -51,6 +51,8 @@ class _TransientStatus(Exception):
 
 async def stream_frames(client, session_id: str, headers_provider, *,
                         start_id: str = "0-0", force_refresh=None, on_retry=None):
+    from webbee.http import WakeDetector
+    woke = WakeDetector()
     last_id = start_id or "0-0"
     backoff = _BACKOFF_BASE
     attempt = 0
@@ -105,6 +107,8 @@ async def stream_frames(client, session_id: str, headers_provider, *,
                         yield frame
         except (httpx.HTTPError, OSError, _TransientStatus, _TransientAuth):
             attempt += 1
+            if woke.check():
+                backoff = _BACKOFF_BASE      # the machine slept: reconnect now, not after the old backoff
             delay = min(backoff, _BACKOFF_MAX)
             if on_retry is not None:
                 try:

{webbee-0.5.2 → webbee-0.5.3}/src/webbee/tools.py

@@ -627,7 +627,10 @@ class LocalToolExecutor:
         pat = re.compile(a["pattern"])
         base = self.resolve_in_workspace(a.get("path", "."))
         hits = []
-        for dp, dns, fns in os.walk(base):
+        # a single file is searched itself: os.walk() yields nothing for a file, so every grep on
+        # one file answered "(no matches)" (live 2026-10-20: 30 of 34 single-file greps were false)
+        walk = [(os.path.dirname(base), [], [os.path.basename(base)])] if os.path.isfile(base) else os.walk(base)
+        for dp, dns, fns in walk:
             if _is_git_dir(dp):
                 dns[:] = []
                 continue

{webbee-0.5.2 → webbee-0.5.3}/src/webbee/tui.py

@@ -21,6 +21,8 @@ import asyncio
 import os
 import re
 
+from prompt_toolkit.layout.dimension import Dimension
+
 from webbee import __version__, sizing
 from webbee.output_pane import OutputPane  # noqa: F401 — re-exported (webbee.tui.OutputPane)
 from webbee.queue_panel import (drop_item, one_line, pull_item, queue_fragments,
@@ -1047,7 +1049,7 @@ async def run_session(*, slots, on_line, on_cycle, on_tier_cycle=None,
         from prompt_toolkit.filters import Condition
         from prompt_toolkit.key_binding import KeyBindings
         from prompt_toolkit.layout import (ConditionalContainer, DynamicContainer,
-                                          HSplit, Layout, Window)
+                                          HSplit, Layout, Window, Dimension)
         from prompt_toolkit.layout.controls import BufferControl, FormattedTextControl
         from prompt_toolkit.layout.processors import BeforeInput
         from prompt_toolkit.styles import Style
@@ -2367,6 +2369,16 @@ async def run_session(*, slots, on_line, on_cycle, on_tier_cycle=None,
 
     def _tab_fragments_live():
         cols, _rows = sizing.get_size(get_app_or_none())
+        cols = max(cols, 20)
+        # INVARIANT: tab_bar Window must NEVER scroll vertically.
+        # If vertical_scroll ever reaches 1, prompt_toolkit renders line 1 (empty),
+        # which makes the entire top tab bar disappear or get 'eaten' by the screen.
+        if "tab_bar" in locals() and tab_bar is not None:
+            try:
+                tab_bar.vertical_scroll = 0
+                tab_bar.horizontal_scroll = 0
+            except Exception:
+                pass
         return tab_fragments(slots, on_switch=_switch_to, on_close=_close_tab_click,
                              on_new=_new_tab_click, width=cols,
                              forward=lambda ev: _pane().forward_mouse(ev, clamp="top"),
@@ -2381,12 +2393,14 @@ async def run_session(*, slots, on_line, on_cycle, on_tier_cycle=None,
     # every chip on its own solid bar (`"tabbar": "bg:#262626"` in the Style
     # dict below) — a browser look, visually separated from the transcript
     # above/below it instead of floating directly on the terminal's own bg.
-    tab_bar = Window(FormattedTextControl(_tab_fragments_live, focusable=False),
-                     height=1, always_hide_cursor=True, style="class:tabbar")
-    # ONE blank row of breathing room between the bar and the transcript —
-    # deliberately bare (no style at all): it renders as plain terminal
-    # background, transparent-looking, never a second colored stripe.
-    tab_bar_spacer = Window(height=1)
+    # CRITICAL FIX (top bar disappearing): wrap_lines=False, always_hide_cursor=True,
+    # and dont_extend_height=True prevent prompt_toolkit from scrolling
+    # vertically or wrapping tabs into line 2, which caused the entire top bar
+    # to disappear or get 'eaten' during tab switching, resize or mouse wheel scroll.
+    tab_bar = Window(FormattedTextControl(_tab_fragments_live, focusable=False, show_cursor=False),
+                     height=Dimension.exact(1), always_hide_cursor=True,
+                     wrap_lines=False, style="class:tabbar", dont_extend_height=True)
+    tab_bar_spacer = Window(height=Dimension.exact(1), dont_extend_height=True)
     # The single most structural change of the W4a wave (map §3): the pane
     # slot in the root layout is a DynamicContainer, not a bound window —
     # it re-resolves `slots.active().pane.window` on EVERY redraw, so a tab

webbee-0.5.3/tests/test_home_view_mouse.py

@@ -0,0 +1,11 @@
+import pytest
+from webbee.slots import SlotManager, SessionSlot
+from webbee.home_view import HomeView
+from webbee.output_pane import OutputPane
+
+def test_home_view_has_forward_mouse():
+    slots = SlotManager()
+    hv = HomeView(slots=slots, actions={})
+    assert hasattr(hv, "forward_mouse"), "HomeView must have forward_mouse to prevent AttributeError on tab switch or mouse events"
+    # Should accept ev and clamp without crashing
+    hv.forward_mouse(None, clamp="top")

webbee-0.5.3/tests/test_resilient_http.py

@@ -0,0 +1,21 @@
+from webbee.http import WakeDetector, make_client, socket_options
+from webbee.config import Config
+
+
+def test_a_long_idle_wait_is_not_a_sleep_but_a_clock_drift_is():
+    t = {"wall": 1000.0, "mono": 50.0}
+    d = WakeDetector(8.0, wall=lambda: t["wall"], mono=lambda: t["mono"])
+    t["wall"] += 60; t["mono"] += 60          # 60s idle: both clocks move
+    assert d.check() is False
+    t["wall"] += 600; t["mono"] += 2          # the laptop slept ~10 minutes
+    assert d.check() is True
+    t["wall"] += 4; t["mono"] += 4
+    assert d.check() is False
+
+
+def test_the_client_sockets_carry_keepalive():
+    import socket
+    opts = socket_options()
+    assert (socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1) in opts
+    client = make_client(Config(api_url="https://api.imperal.io", panel_url="https://panel.imperal.io"))
+    assert client.timeout.read == 10.0

{webbee-0.5.2 → webbee-0.5.3}/tests/test_sizing.py

@@ -11,8 +11,9 @@ def test_get_size_prefers_pt_output():
 
 
 def test_get_size_falls_back_without_app(monkeypatch):
+    import os
     import shutil
-    monkeypatch.setattr(shutil, "get_terminal_size", lambda fb: type("S", (), {"columns": 91, "lines": 22})())
+    monkeypatch.setattr(shutil, "get_terminal_size", lambda *args, **kwargs: os.terminal_size((91, 22)))
     assert get_size(None) == (91, 22)
 
 

webbee-0.5.3/tests/test_tab_bar_stability.py

@@ -0,0 +1,38 @@
+import pytest
+from prompt_toolkit.layout.containers import Window
+from webbee.slots import SlotManager
+from webbee.tabs import tab_fragments
+import webbee.sizing as sizing
+
+def test_tab_bar_clamping_and_no_wrap():
+    from webbee.slots import SessionSlot
+    sm = SlotManager()
+    # Add a slot
+    slot2 = SessionSlot(kind="session", workspace="/tmp", label="Tab 1", pane=None, sink=None, agent=None)
+    sm.add(slot2)
+    assert sm.session_count() == 1
+    
+    # Check tab fragments with normal width
+    frags = tab_fragments(sm, on_switch=lambda x: None, on_close=lambda x: None, width=80)
+    assert len(frags) > 0
+    
+    # Check tab fragments with narrow width - should never raise or collapse
+    frags_narrow = tab_fragments(sm, on_switch=lambda x: None, on_close=lambda x: None, width=10)
+    assert len(frags_narrow) > 0
+
+    # Check tab fragments with zero or negative width
+    frags_zero = tab_fragments(sm, on_switch=lambda x: None, on_close=lambda x: None, width=0)
+    assert len(frags_zero) > 0
+    frags_neg = tab_fragments(sm, on_switch=lambda x: None, on_close=lambda x: None, width=-5)
+    assert len(frags_neg) > 0
+
+def test_tab_bar_window_scroll_invariants():
+    # Verify that Window representing tab bar has always_hide_cursor and wrap_lines=False
+    # to avoid prompt_toolkit line wrapping or vertical scrolling that eats the top bar
+    from prompt_toolkit.layout.controls import FormattedTextControl
+    from prompt_toolkit.filters import to_filter
+    control = FormattedTextControl([("", "tab text")])
+    w = Window(content=control, height=1, dont_extend_height=True, wrap_lines=False, always_hide_cursor=True)
+    assert to_filter(w.wrap_lines)() is False
+    assert to_filter(w.always_hide_cursor)() is True
+

webbee-0.5.3/tests/test_tier_invalidation.py

@@ -0,0 +1,20 @@
+import pytest
+from webbee.slots import SlotManager, SessionSlot
+from webbee.repl import set_slot_tier
+from webbee.tier_store import load_tier, save_tier
+
+def test_set_slot_tier_propagates_and_invalidates(tmp_path):
+    class DummyAgent:
+        def __init__(self):
+            self.model_tier = ""
+            self.invalidated = False
+        def invalidate_cache(self):
+            self.invalidated = True
+
+    workspace = str(tmp_path)
+    slot = SessionSlot(kind="session", workspace=workspace, label="TestSlot", pane=None, sink=None, agent=DummyAgent())
+    
+    set_slot_tier(slot, "ultrasmart")
+    assert slot.model_tier == "ultrasmart"
+    assert slot.agent.model_tier == "ultrasmart"
+    assert load_tier(workspace) == "ultrasmart"

{webbee-0.5.2 → webbee-0.5.3}/tests/test_tools.py

@@ -37,6 +37,15 @@ def test_grep(tmp_path):
     assert r["ok"] and "a.py" in r["content"]
 
 
+def test_grep_on_a_single_file(tmp_path):
+    """live 2026-10-20: every grep whose path was one file answered "(no matches)"."""
+    ex = _ex(tmp_path)
+    ex.run("write_file", {"path": "app/writers.py", "content": "x = 1\n@writer\ndef save():\n    pass\n"})
+    r = ex.run("grep", {"pattern": "@writer", "path": "app/writers.py"})
+    assert r["ok"] and r["match_count"] == 1 and r["content"] == os.path.join("app", "writers.py") + ":2:@writer"
+    assert ex.run("grep", {"pattern": "nothing", "path": "app/writers.py"})["content"] == "(no matches)"
+
+
 def test_grep_skips_git_dir(tmp_path):
     # Real regression coverage on this (posix) host: a matching file sitting
     # inside .git/ must never surface in results.

webbee-0.5.2/src/webbee/__init__.py

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

webbee-0.5.2/src/webbee/http.py

@@ -1,11 +0,0 @@
-"""ONE keep-alive httpx.AsyncClient for the client's small gateway calls.
-Before W1 the idle-steer poller opened a NEW AsyncClient — a fresh TCP+TLS
-handshake — every 4s tick, forever (thread.py per-call clients). The repl owns
-one client for the loop's lifetime and passes it down; every callee keeps a
-per-call fallback so tests and old call sites work unchanged."""
-from __future__ import annotations
-
-
-def make_client(cfg):
-    import httpx
-    return httpx.AsyncClient(base_url=cfg.api_url, timeout=10)