webbee 0.3.43__tar.gz → 0.3.45__tar.gz

{webbee-0.3.43 → webbee-0.3.45}/CHANGELOG.md

@@ -1,5 +1,47 @@
 # Changelog
 
+## 0.3.45
+
+Consent prompts stop being an easy-to-miss detail:
+
+- **Both the kernel consent (`? approve ...`) and the local remote-control
+  yes/no ask now print as a bordered card, right in the conversation, the
+  moment they're asked** -- the same proven Panel this terminal already
+  uses for the billing and login prompts, so it reflows correctly to
+  whatever width the terminal actually has (a phone's SSH client, a narrow
+  tmux pane, a full window). The question and the "how to answer"
+  instructions (`y/yes -> do it`, `n/no -> skip it`, or type your own
+  reply) now live in the SAME box -- nothing to go hunting for in a
+  toolbar hint several rows away. The underlying protocol is unchanged:
+  still a bare raw string relayed verbatim for the kernel to interpret
+  (ICNLI, safe-by-default) -- this is a display-only change.
+
+## 0.3.44
+
+Three real Home-dashboard bugs, found and fixed:
+
+- **Each open tab's elapsed time now actually ticks live, per tab.** The
+  numbers themselves were always computed correctly per-tab, but Home only
+  ever redrew while a turn was busy or a toast was fresh -- sitting idle on
+  Home (the normal way to look at your tabs) froze every age at whatever it
+  was the moment you switched there, which looked exactly like "one shared
+  time for all tabs" even though it wasn't. Home now redraws on the plain
+  1s idle tick too, so every tab's own age genuinely counts up in place.
+- **"Your devices" no longer lists dead terminal sessions.** A crashed
+  terminal or a laptop that lost network never calls the gateway's revoke
+  endpoint on its way out, so the raw session listing accumulated stale
+  entries forever. The list now hides a row only once its own last-activity
+  timestamp proves it's actually gone (>24h) -- your current device always
+  shows, and a row with no timestamp at all (older data) still shows rather
+  than risk hiding something real.
+- **The notification toggle now reflects what the server actually
+  confirmed, not just what you clicked.** The old code echoed the click's
+  raw argument straight into the display the instant the request was sent,
+  so a write the server silently rejected or normalized still looked like
+  it had taken effect. It now reads back the server's own state after the
+  write, and clicking with no session tab open tells you plainly instead of
+  doing nothing silently.
+
 ## 0.3.43
 
 Honest fix-up of three things 0.3.42 got wrong or left unfinished:

{webbee-0.3.43 → webbee-0.3.45}/PKG-INFO

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

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

webbee-0.3.45/src/webbee/__init__.py

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

{webbee-0.3.43 → webbee-0.3.45}/src/webbee/home.py

@@ -100,6 +100,49 @@ def _device_label(s: dict) -> str:
     return "session"
 
 
+DEVICE_STALE_TTL_S = 24 * 3600  # webbee-code-home-live-devices-v1
+
+
+def _is_recently_active(s: dict, now: float, ttl: float = DEVICE_STALE_TTL_S) -> bool:
+    """PURE. Whether a `/v1/auth/sessions` row is worth showing on Home's
+    device list. `/v1/auth/sessions` lists every session token the gateway
+    has ever ISSUED that hasn't been explicitly revoked -- a terminal that
+    crashed or a laptop that lost network never calls revoke on its way out,
+    so the raw listing accumulates dead entries forever (Valentin, live
+    2026-07-31: "a bunch of dead terminal sessions"). The CURRENT session
+    (`current`/`is_current`) always counts as active regardless of its own
+    timestamp -- it's the one you're looking at right now. Every other row
+    is checked against `last_seen_at` (or `updated_at`/`created_at` as a
+    fallback) when the gateway actually SENDS one of those fields: only a
+    successfully-parsed timestamp older than `ttl` hides the row. A row with
+    NONE of those fields at all (an older gateway shape that never sends
+    them) degrades the OTHER way -- unknown is shown, never hidden, since
+    hiding a device we simply have no data on risks hiding a real one; only
+    a row we can actually PROVE is stale gets filtered out."""
+    if bool(s.get("current") or s.get("is_current")):
+        return True
+    for k in ("last_seen_at", "updated_at", "created_at"):
+        iso = s.get(k)
+        if not iso:
+            continue
+        try:
+            from datetime import datetime, timezone
+            ss = str(iso).replace("Z", "+00:00")
+            dt = datetime.fromisoformat(ss)
+            if dt.tzinfo is None:
+                dt = dt.replace(tzinfo=timezone.utc)
+            age = (datetime.now(timezone.utc) - dt).total_seconds()
+            if age < 0:
+                continue   # malformed (future) timestamp -- try the next field
+            return age <= ttl
+        except Exception:
+            continue
+    # every timestamp field was absent, unparseable, or in the future:
+    # unknown, not PROVEN stale -- show it (see docstring) rather than
+    # silently hide a real device we simply have no good data on.
+    return True
+
+
 async def fill_home(slot, *, cfg, token_provider, slots, account_fetcher,
                     sessions_client, resources, version, wallet_fetcher=None) -> None:
     """Populate the Home dashboard's HomeData, best-effort, staged (a repaint
@@ -161,9 +204,14 @@ async def fill_home(slot, *, cfg, token_provider, slots, account_fetcher,
 
         try:
             listing = await sessions_client.list_sessions(cfg, token_provider)
+            # webbee-code-home-live-devices-v1: drop rows the gateway never
+            # got a chance to revoke (crashed terminal, dead laptop) so the
+            # list reads as "your real devices", not a graveyard of old
+            # terminal sessions -- see _is_recently_active's own docstring.
+            now = time.time()
             data.devices = [DeviceRow(label=_device_label(s),
                                       current=bool(s.get("current") or s.get("is_current")))
-                            for s in (listing or [])]
+                            for s in (listing or []) if _is_recently_active(s, now)]
         except Exception:
             data.devices = []
         _repaint()

{webbee-0.3.43 → webbee-0.3.45}/src/webbee/render.py

@@ -614,12 +614,38 @@ class RichSink:
         NEVER interpret (the kernel decides, ICNLI). When the dock is running
         the reply comes through the pinned box via an asyncio.Future (no
         blocking input on the event loop); otherwise fall back to the injected
-        sync reader (tests / non-tty)."""
+        sync reader (tests / non-tty).
+
+        webbee-code-consent-card-v1: this used to be one dim, easy-to-miss
+        line in the feed plus a SEPARATE hint buried in the toolbar below --
+        several users said it wasn't obvious what was even being asked, let
+        alone how to answer it. Now it's a bordered card printed RIGHT IN
+        THE CONVERSATION, at the moment it's asked -- same proven Panel this
+        module already uses for the billing/login prompts, so it reflows to
+        whatever width the terminal actually has (phone SSH client, a narrow
+        tmux pane, a full-width window -- all get a readable card, not a
+        clipped line). The question AND the "how to answer" instructions
+        live in the SAME box, so there's nothing to hunt for elsewhere on
+        screen. The protocol contract is unchanged: still a bare raw string
+        relayed verbatim for the kernel to interpret (ICNLI, safe-by-default)."""
         label = _clean(f"{app_id}·{tool}" if app_id else tool)
-        sal = _clean(_salient_arg(args))
-        w = self.console.width
-        self.console.print(Text.assemble(("  ? approve ", "yellow"), (label, "dim"),
-                                          (("  " + sal[:trunc(w, 0.4, 60)]) if sal else "", "dim")))
+        sal = _clean(_salient_arg(args))[:500]
+        body = Text()
+        body.append(label, style=f"bold {_ACCENT}")
+        if sal:
+            body.append("\n" + sal, style="white")
+        body.append("\n\n")
+        body.append("y", style="bold green")
+        body.append(" / ", style="dim")
+        body.append("yes", style="bold green")
+        body.append("  →  do it     ", style="dim")
+        body.append("n", style="bold red")
+        body.append(" / ", style="dim")
+        body.append("no", style="bold red")
+        body.append("  →  skip it\n", style="dim")
+        body.append("or just type your own reply in any language — Enter to send", style="dim")
+        self.console.print(_pad(Panel(body, title="🔐 wants to do this — approve?",
+                                      border_style=_BEE)))
         fut = self._arm_consent(label, sal)
         if fut is None:                       # non-tty / no running app
             raw = self._input("     ")
@@ -643,8 +669,26 @@ class RichSink:
         all return False, so the caller keeps the current mode. This is a
         LOCAL policy decision, not a kernel consent, so the reply is
         interpreted here rather than relayed (ICNLI raw-relay applies to
-        kernel consents only)."""
-        self.console.print(_pad(Text("⚠ " + _clean(question), style=f"bold {_BEE}")))
+        kernel consents only).
+
+        webbee-code-consent-card-v1: same bordered-card treatment as
+        ask_consent -- a bare "⚠ ..." line was just as easy to miss as the
+        old one-line kernel consent was. The card reflows to the terminal's
+        real width on any device, and states the y/n instructions right
+        where the question is instead of leaving them implicit."""
+        body = Text()
+        body.append(_clean(question), style=f"bold {_BEE}")
+        body.append("\n\n")
+        body.append("y", style="bold green")
+        body.append(" / ", style="dim")
+        body.append("yes", style="bold green")
+        body.append("  →  allow     ", style="dim")
+        body.append("n", style="bold red")
+        body.append(" / ", style="dim")
+        body.append("no", style="bold red")
+        body.append("  →  stay as-is (default)", style="dim")
+        self.console.print(_pad(Panel(body, title="⚠ another surface is asking",
+                                      border_style=_BEE)))
         fut = self._arm_consent(question, question)
         try:
             if fut is None:                    # non-tty / no dock → sync reader

{webbee-0.3.43 → webbee-0.3.45}/src/webbee/repl.py

@@ -1727,17 +1727,33 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
                 state["new_tab_mode"] = newtab_mode.load_newtab_mode() or mode
 
                 def _home_set_notify(arg: str) -> None:
+                    # webbee-code-home-live-notify-v1: resolve the TARGET
+                    # session ONCE, up front, and thread that SAME sid through
+                    # to the write below -- the old code re-resolved
+                    # "whichever session Home currently points at" only inside
+                    # the click handler, which is fine, but never told the
+                    # user anything when there was no session tab to apply it
+                    # to (silent no-op looked exactly like "did nothing" --
+                    # Valentin, live 2026-07-31: "doesn't show real values").
                     picked = _pick_session_slot(slots)
                     sid = getattr(getattr(picked, "agent", None), "session_id", "") if picked else ""
                     if not sid:
+                        home_view.data.notice = "open a session tab first — notifications are per-session"
+                        home_view.notify()
                         return
                     async def _do():
                         try:
                             st = await _remote_mod.set_remote(cfg, token_provider, sid, arg)
-                            home_view.data.notify_state = arg
+                            # webbee-code-home-live-notify-v1: show what the
+                            # SERVER actually confirmed (from_notify_state_from
+                            # its own state), never the raw click argument --
+                            # the old code trusted `arg` unconditionally, so a
+                            # write the server silently rejected/normalized
+                            # still displayed as if it had taken effect.
+                            home_view.data.notify_state = home._notify_state_from(st)
                             home_view.data.remote_desc = _remote_mod.describe(st)
                         except Exception:
-                            pass
+                            home_view.data.notice = "couldn't update notifications — try again"
                         home_view.notify()
                     get_app().create_background_task(_do())
 

{webbee-0.3.43 → webbee-0.3.45}/src/webbee/tui.py

@@ -477,7 +477,8 @@ def _tick_once(slots, app, is_busy, breathing=None) -> None:
     when a turn is running OR the copy-flash toast is still fresh, so the
     spinner/elapsed-clock/flash-expiry all animate without redrawing on every
     idle tick for nothing."""
-    pane = slots.active().pane
+    active = slots.active()
+    pane = active.pane
     _width_watch(pane, app)
     try:
         pane.edge_tick()
@@ -488,7 +489,17 @@ def _tick_once(slots, app, is_busy, breathing=None) -> None:
     # state right now -- if so the idle 1.0s-cadence tick still has to
     # actually REDRAW so the alternating shade is ever seen, not just
     # computed and silently discarded on every tick the same as a no-op one.
-    if is_busy() or pane.flash() or (breathing is not None and breathing()):
+    # webbee-code-home-live-ages-v1: Home's own tab-list ages/durations are
+    # computed FRESH every render (home_view.tab_rows reads time.monotonic()
+    # each call) -- but a render only happens on an app.invalidate(), and the
+    # busy/flash/breathing checks above are ALL false while you're simply
+    # sitting on Home doing nothing. That froze every age at whatever it was
+    # the moment you switched to Home -- looking like one shared, wrong
+    # number instead of each tab's own live-ticking age. Home is cheap to
+    # redraw (same virtualized-slice render every other pane already does),
+    # so it gets the plain 1s idle cadence's invalidate too, unconditionally.
+    if (is_busy() or pane.flash() or (breathing is not None and breathing())
+            or getattr(active, "kind", "") == "home"):
         app.invalidate()
 
 

{webbee-0.3.43 → webbee-0.3.45}/tests/test_home.py

@@ -4,8 +4,8 @@ tiles, async best-effort fill, is_stale/refill scheduling, and home_input's
 import asyncio
 
 from webbee.account import Account
-from webbee.home import (_mask_email, _notify_state_from, _pick_session_slot,
-                         fill_home, is_stale)
+from webbee.home import (_is_recently_active, _mask_email, _notify_state_from,
+                         _pick_session_slot, fill_home, is_stale)
 from webbee.repl import _home_input, _home_target_workspace, _schedule_home_refill
 from webbee.slots import SessionSlot, SlotManager, WorkspaceResources
 from webbee.wallet import Wallet
@@ -175,6 +175,53 @@ def test_fill_home_builds_device_rows_without_pii():
     assert not any("1.2.3.4" in lbl for lbl in labels)   # raw IP never surfaced
 
 
+def test_is_recently_active_keeps_current_regardless_of_timestamp():
+    # webbee-code-home-live-devices-v1: the row you're looking at right now
+    # always counts as active, even with a wildly stale/missing timestamp.
+    assert _is_recently_active({"current": True}, now=1_000_000.0) is True
+    assert _is_recently_active({"is_current": True, "last_seen_at": "2000-01-01T00:00:00Z"},
+                               now=1_000_000.0) is True
+
+
+def test_is_recently_active_hides_a_proven_stale_row():
+    from datetime import datetime, timedelta, timezone
+    old_ts = (datetime.now(timezone.utc) - timedelta(days=40)).isoformat()
+    assert _is_recently_active({"last_seen_at": old_ts}, now=0.0) is False
+
+
+def test_is_recently_active_shows_a_recent_row():
+    from datetime import datetime, timezone
+    fresh_ts = datetime.now(timezone.utc).isoformat()
+    assert _is_recently_active({"last_seen_at": fresh_ts}, now=0.0) is True
+
+
+def test_is_recently_active_shows_unknown_rows_never_proven_stale():
+    # No timestamp field at all (older gateway shape) -- unknown, not
+    # PROVEN stale, so it must still show rather than silently vanish.
+    assert _is_recently_active({"label": "old client"}, now=0.0) is True
+    # An unparseable timestamp degrades the same safe way.
+    assert _is_recently_active({"last_seen_at": "not-a-date"}, now=0.0) is True
+
+
+def test_fill_home_filters_stale_devices():
+    from datetime import datetime, timedelta, timezone
+    async def acct(cfg, tp):
+        return Account(signed_in=False)
+    fresh_ts = datetime.now(timezone.utc).isoformat()
+    stale_ts = (datetime.now(timezone.utc) - timedelta(days=40)).isoformat()
+    listing = [{"label": "this laptop", "current": True},
+               {"label": "dead terminal", "last_seen_at": stale_ts},
+               {"label": "phone, recently used", "last_seen_at": fresh_ts}]
+    home = _home_slot()
+    slots = SlotManager(); slots.add(home)
+    asyncio.run(fill_home(home, cfg=_Cfg(), token_provider=_tok, slots=slots,
+                          account_fetcher=acct, sessions_client=_FakeSessions(listing),
+                          resources=WorkspaceResources(), version="1.0.0", wallet_fetcher=None))
+    labels = [r.label for r in home.pane.data.devices]
+    assert labels == ["this laptop", "phone, recently used"]
+    assert "dead terminal" not in labels
+
+
 def test_fill_home_reentrancy_guard():
     calls = []
     async def counting(cfg, tp):

{webbee-0.3.43 → webbee-0.3.45}/tests/test_render.py

@@ -299,6 +299,49 @@ def test_consent_shows_human_summary_not_dict():
     assert "notes·delete_note" in out
 
 
+# ── webbee-code-consent-card-v1: the consent card is a real, hard-to-miss
+# bordered block printed IN the conversation, with the y/n instructions
+# living right next to the question -- not a dim one-liner + a separate
+# toolbar hint the user has to go hunting for. ────────────────────────────
+
+def test_consent_is_a_bordered_card_with_inline_instructions():
+    console = Console(record=True, width=90)
+    s = RichSink(console=console, live_enabled=False,
+                 input_fn=lambda p: "yes", clock=lambda: 0.0)
+    asyncio.run(s.ask_consent("notes", "delete_note", {"title": "Q3 budget"}))
+    out = console.export_text()
+    # a real Panel border, not a bare printed line
+    assert "\u256d" in out or "\u2500" in out   # rounded-corner or horizontal rule glyph
+    assert "approve?" in out
+    # the how-to-answer instructions are IN the card, not somewhere else
+    assert "yes" in out and "no" in out
+    assert "do it" in out and "skip it" in out
+    assert "notes·delete_note" in out
+
+
+def test_consent_card_reflows_to_narrow_terminal_width():
+    # A phone SSH client / narrow tmux pane: the card must not crash or
+    # silently drop the question -- Panel reflows, same as billing/login.
+    console = Console(record=True, width=28)
+    s = RichSink(console=console, live_enabled=False,
+                 input_fn=lambda p: "y", clock=lambda: 0.0)
+    asyncio.run(s.ask_consent("mail", "delete", {"query": "old newsletters"}))
+    out = console.export_text()
+    assert "mail" in out and "delete" in out
+    assert "yes" in out and "no" in out
+
+
+def test_ask_yes_no_is_also_a_bordered_card_with_instructions():
+    console = Console(record=True, width=90)
+    s = RichSink(console=console, live_enabled=False,
+                 input_fn=lambda p: "y", clock=lambda: 0.0)
+    asyncio.run(s.ask_yes_no("switch to autopilot — allow? [y/n]"))
+    out = console.export_text()
+    assert "\u256d" in out or "\u2500" in out
+    assert "allow" in out.lower()
+    assert "yes" in out and "no" in out
+
+
 def test_user_echo_is_unboxed_line():
     s = _sink()
     s.user_echo("delete my Q3 note")

{webbee-0.3.43 → webbee-0.3.45}/tests/test_tui.py

@@ -1548,6 +1548,43 @@ def test_tick_once_fires_width_watch_edge_tick_and_invalidate(monkeypatch):
     assert calls["invalidate"] == 2    # is_busy() True -> app.invalidate()
 
 
+def test_tick_once_always_invalidates_on_home_even_when_idle(monkeypatch):
+    # webbee-code-home-live-ages-v1: Home's tab list computes each tab's own
+    # age fresh every render, but a render only happens on invalidate() --
+    # so sitting idle on Home (not busy, no flash, not breathing) must NOT
+    # skip the redraw the way every other idle pane correctly does, or every
+    # tab's elapsed time freezes at whatever it was when you switched here.
+    from webbee.tui import _tick_once
+
+    class _Pane:
+        def __init__(self):
+            self.console = type("Console", (), {"width": 72})()
+        def reflow(self, cols):
+            pass
+        def edge_tick(self):
+            pass
+        def flash(self):
+            return ""
+
+    class _App:
+        def __init__(self):
+            self.n = 0
+        def invalidate(self):
+            self.n += 1
+
+    monkeypatch.setattr("webbee.sizing.get_size", lambda app: (72, 24))
+    slots = mk_slots(pane=_Pane())
+    slots.slots[0].kind = "home"
+    app = _App()
+    _tick_once(slots, app, lambda: False)   # idle, no breathing
+    assert app.n == 1   # still invalidated because the active slot is Home
+
+    slots.slots[0].kind = "session"
+    app2 = _App()
+    _tick_once(slots, app2, lambda: False)
+    assert app2.n == 0   # a genuinely idle SESSION tab still skips the redraw
+
+
 def test_tick_once_swallows_edge_tick_error(monkeypatch):
     from webbee.tui import _tick_once
 

webbee-0.3.43/src/webbee/__init__.py

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