webbee 0.3.7__tar.gz → 0.3.8__tar.gz

{webbee-0.3.7 → webbee-0.3.8}/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.3.8
+
+- No more sign-in races: token refresh is serialized and retries once after
+  a sibling terminal rotates the session — multiple open terminals no longer
+  knock each other out with "session expired".
+- No more dock lockup: a turn that fails (for example, an expired session)
+  now clears the "working" state, and every key keeps responding even if the
+  turn state ever goes stale. The idle pickup poller also backs off instead
+  of hammering a signed-out session.
+
 ## 0.3.7
 
 - Terminal liveness: a consent answered from Telegram/panel no longer

{webbee-0.3.7 → webbee-0.3.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: webbee
-Version: 0.3.7
+Version: 0.3.8
 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.3.7 → webbee-0.3.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "webbee"
-version = "0.3.7"
+version = "0.3.8"
 description = "Webbee 🐝 — the Imperal Cloud coding agent in your terminal"
 readme = "README.md"
 license = "MIT"

webbee-0.3.8/src/webbee/__init__.py

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

{webbee-0.3.7 → webbee-0.3.8}/src/webbee/repl.py

@@ -58,8 +58,8 @@ async def run_marathon(cfg, mode: str, goal: str, *, sink=None, auth=None,
 
     workspace = os.getcwd()
 
-    async def token_provider() -> str:
-        return await auth.ensure_access_token(cfg)
+    from webbee.tokens import make_token_provider
+    token_provider = make_token_provider(cfg, auth)
 
     if agent_factory is None:
         agent_factory = lambda c, tp, ws, m: AgentSession(c, tp, ws, m)  # noqa: E731
@@ -72,9 +72,11 @@ async def run_marathon(cfg, mode: str, goal: str, *, sink=None, auth=None,
     except (KeyboardInterrupt, asyncio.CancelledError):
         await agent.stop()
         sink.note("Interrupted.")
+        sink.end_turn("")   # clear busy (poller starvation guard)
         return ""
     except Exception as e:  # network/auth/etc — never crash
         sink.note(f"Error: {type(e).__name__}: {e}")
+        sink.end_turn("")   # clear busy: a stuck 'working' also starves the idle-steer poller
         return ""
     sink.end_turn(text)
     return text
@@ -122,8 +124,8 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
 
     workspace = os.getcwd()
 
-    async def token_provider() -> str:
-        return await auth.ensure_access_token(cfg)
+    from webbee.tokens import make_token_provider
+    token_provider = make_token_provider(cfg, auth)
 
     # Prod dock path = the default reader + a real tty + no injected sink; tests
     # inject sink/read_line and take the plain fallback loop.
@@ -287,9 +289,11 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
         except (KeyboardInterrupt, asyncio.CancelledError):
             _sink.abort()
             _sink.note("Interrupted.")
+            _sink.end_turn("")   # clear busy (poller starvation guard)
             return
         except Exception as e:  # network/auth/etc — never crash the REPL
             _sink.note(f"Error: {type(e).__name__}: {e}")
+            _sink.end_turn("")   # clear busy: a stuck 'working' also starves the idle-steer poller
             return
         _sink.end_turn(text)
 

{webbee-0.3.7 → webbee-0.3.8}/src/webbee/steer.py

@@ -73,8 +73,10 @@ async def poll_idle_steer(cfg, token_provider, *, workspace: str, is_busy,
     from webbee.thread import fetch_pending_steer
     derived = ""
     backlog: deque = deque()
+    failures = 0    # consecutive fetch/auth failures -> backoff (a logged-out
+                    # terminal must not hammer the token-refresh path every 4s)
     while True:
-        await asyncio.sleep(interval)
+        await asyncio.sleep(min(interval * (2 ** min(failures, 4)), 60.0))
         try:
             if is_busy():
                 continue
@@ -103,4 +105,8 @@ async def poll_idle_steer(cfg, token_provider, *, workspace: str, is_busy,
         except Exception:
             # Fail-soft by design: a network blip / auth hiccup skips this
             # tick; undrained items stay durable on the gateway (1h TTL).
+            # Consecutive failures back the poll off (up to 60s) so a
+            # logged-out terminal never hammers the token-refresh path.
+            failures += 1
             continue
+        failures = 0

webbee-0.3.8/src/webbee/tokens.py

@@ -0,0 +1,39 @@
+"""Serialized token acquisition for every webbee gateway call.
+
+The gateway rotates refresh tokens SINGLE-USE (an atomic claim revokes the
+presented token and mints a new pair) and the SDK's ensure_access_token has
+no lock: two concurrent refreshes at an access-token expiry boundary — the
+idle-steer poller vs. a starting turn, or two open terminals sharing the
+same on-disk creds — race, and the loser's refresh 401s as "session
+expired" (Valentin, live 2026-07-15, right after 0.3.7 made the poller a
+frequent caller).
+
+Two-layer guard:
+  * an asyncio.Lock serializes ALL in-process acquisitions (poller / boot
+    replay / turns never refresh concurrently);
+  * on failure, ONE short-delay retry — ensure_access_token re-reads the
+    creds file, so when a SIBLING terminal won the race and saved the
+    rotated pair, the retry succeeds from its fresh refresh token. A real
+    logged-out state still fails (both attempts), just ~0.6s later.
+"""
+from __future__ import annotations
+
+import asyncio
+
+_RETRY_DELAY_S = 0.6
+
+_lock = asyncio.Lock()
+
+
+def make_token_provider(cfg, auth):
+    """The ONE token_provider factory the REPL/marathon paths share."""
+
+    async def token_provider() -> str:
+        async with _lock:
+            try:
+                return await auth.ensure_access_token(cfg)
+            except Exception:
+                await asyncio.sleep(_RETRY_DELAY_S)
+                return await auth.ensure_access_token(cfg)
+
+    return token_provider

{webbee-0.3.7 → webbee-0.3.8}/src/webbee/tui.py

@@ -157,6 +157,16 @@ async def run_session(*, pane, on_line, mode_getter, on_cycle, status,
 
     kb = KeyBindings()
 
+    def _busy_live() -> bool:
+        """Lockout-proof busy for the key handlers: busy only while the turn
+        TASK is genuinely alive. A turn that died without clearing the sink's
+        busy flag (an error path that skipped end_turn) must never brick the
+        dock -- Enter/Esc/Ctrl-C/Ctrl-D all gate on THIS, so a stale flag
+        degrades to a cosmetic toolbar glitch instead of an unusable input
+        (Valentin, live 2026-07-15: 'working' spun and NO key reacted)."""
+        t = turn.get("task")
+        return bool(is_busy() and t is not None and not t.done())
+
     @kb.add("enter")
     def _enter(event):
         text = scrub_mouse_residue(buf.text)   # never send leaked mouse reports
@@ -164,11 +174,11 @@ async def run_session(*, pane, on_line, mode_getter, on_cycle, status,
         if consent_pending():
             resolve_consent(text)              # ICNLI: relay the raw reply verbatim
             return
-        if not text.strip() and sel["i"] is not None and steps_nav and not is_busy():
+        if not text.strip() and sel["i"] is not None and steps_nav and not _busy_live():
             idx, sel["i"] = sel["i"], None
             event.app.create_background_task(steps_nav["expand"](idx))
             return
-        if is_busy() or not text.strip():
+        if _busy_live() or not text.strip():
             return
         turn["task"] = event.app.create_background_task(_run_turn(text))
 
@@ -179,11 +189,11 @@ async def run_session(*, pane, on_line, mode_getter, on_cycle, status,
 
     @kb.add("c-c")
     def _interrupt(event):
-        _interrupt_action(turn, is_busy, stop_turn, event)
+        _interrupt_action(turn, _busy_live, stop_turn, event)
 
     @kb.add("c-d")
     def _eof(event):
-        if not is_busy():
+        if not _busy_live():
             event.app.exit()
 
     sel = {"i": None}   # None = no selection; else 0-based step index
@@ -197,20 +207,20 @@ async def run_session(*, pane, on_line, mode_getter, on_cycle, status,
     @kb.add("up")
     def _step_up(event):
         n = _nav_count()
-        if n and not buf.text and not is_busy():
+        if n and not buf.text and not _busy_live():
             sel["i"] = (n - 1) if sel["i"] is None else max(0, sel["i"] - 1)
             event.app.invalidate()
 
     @kb.add("down")
     def _step_down(event):
         n = _nav_count()
-        if n and not buf.text and not is_busy():
+        if n and not buf.text and not _busy_live():
             sel["i"] = 0 if sel["i"] is None else min(n - 1, sel["i"] + 1)
             event.app.invalidate()
 
     @kb.add("escape")
     def _step_clear(event):
-        _escape_action(sel, turn, is_busy, stop_turn, event, buf=buf)
+        _escape_action(sel, turn, _busy_live, stop_turn, event, buf=buf)
 
     @kb.add("pageup")
     def _pgup(event):

{webbee-0.3.7 → webbee-0.3.8}/tests/test_repl.py

@@ -162,7 +162,10 @@ def test_agent_error_is_swallowed_and_loop_continues():
     assert agent.tasks == ["do it"]
     assert any("Error" in n for n in sink.notes)
     assert not any(NO_CYRILLIC.search(n) for n in sink.notes)
-    assert sink.turns == []
+    # Liveness: this path MUST clear busy via end_turn("") -- a stuck busy
+    # flag locked the whole dock out (live 2026-07-15) and starves the idle-
+    # steer poller. Empty text = no final panel, just the state reset.
+    assert sink.turns == [""]
 
 
 def test_login_command_calls_auth_and_logs_in():
@@ -234,7 +237,10 @@ def test_ctrl_c_mid_turn_aborts_and_returns_to_prompt():
     assert sink.aborted is True
     assert any("Interrupted" in n for n in sink.notes)
     assert not any(NO_CYRILLIC.search(n) for n in sink.notes)
-    assert sink.turns == []
+    # Liveness: this path MUST clear busy via end_turn("") -- a stuck busy
+    # flag locked the whole dock out (live 2026-07-15) and starves the idle-
+    # steer poller. Empty text = no final panel, just the state reset.
+    assert sink.turns == [""]
 
 
 def test_welcome_shown_on_start():

webbee-0.3.8/tests/test_tokens.py

@@ -0,0 +1,57 @@
+"""Serialized token provider (webbee.tokens) — the anti-lockout auth guard."""
+import asyncio
+
+import pytest
+
+from webbee.tokens import make_token_provider
+
+
+class _Auth:
+    def __init__(self, fail_first: int = 0):
+        self.calls = 0
+        self.concurrent = 0
+        self.max_concurrent = 0
+        self.fail_first = fail_first
+
+    async def ensure_access_token(self, cfg):
+        self.calls += 1
+        self.concurrent += 1
+        self.max_concurrent = max(self.max_concurrent, self.concurrent)
+        try:
+            await asyncio.sleep(0.01)
+            if self.calls <= self.fail_first:
+                raise RuntimeError("invalid refresh token")
+            return f"tok{self.calls}"
+        finally:
+            self.concurrent -= 1
+
+
+def test_concurrent_acquisitions_serialized():
+    auth = _Auth()
+    tp = make_token_provider(object(), auth)
+
+    async def go():
+        return await asyncio.gather(tp(), tp(), tp())
+
+    toks = asyncio.run(go())
+    assert all(t.startswith("tok") for t in toks)
+    assert auth.max_concurrent == 1          # the lock: never two refreshes at once
+
+
+def test_failure_retries_once_after_sibling_rotation(monkeypatch):
+    import webbee.tokens as wt
+    monkeypatch.setattr(wt, "_RETRY_DELAY_S", 0)
+    auth = _Auth(fail_first=1)               # first attempt loses the rotation race
+    tp = make_token_provider(object(), auth)
+    assert asyncio.run(tp()) == "tok2"       # retry re-reads (sibling saved) and wins
+    assert auth.calls == 2
+
+
+def test_true_logged_out_still_fails(monkeypatch):
+    import webbee.tokens as wt
+    monkeypatch.setattr(wt, "_RETRY_DELAY_S", 0)
+    auth = _Auth(fail_first=99)
+    tp = make_token_provider(object(), auth)
+    with pytest.raises(RuntimeError):
+        asyncio.run(tp())
+    assert auth.calls == 2                   # exactly one retry, no hammering

webbee-0.3.7/src/webbee/__init__.py

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