webbee 0.3.35__tar.gz → 0.3.37__tar.gz

{webbee-0.3.35 → webbee-0.3.37}/CHANGELOG.md

@@ -1,5 +1,65 @@
 # Changelog
 
+## 0.3.37
+
+Your tabs come back, the queue does what you tell it, and the version sits
+where you asked for it.
+
+- **Closing the terminal no longer throws your work away.** Three tabs of live
+  work used to become one empty tab on the next start. Your layout is
+  remembered per repo and restored on boot — and it is reconciled against what
+  is *actually* still running, so a tab that really ended comes back as a
+  labelled tab rather than a dead one pretending to be alive. An accidental
+  exit, Ctrl-D and a crash all remember equally. Autopilot is deliberately
+  never remembered: a mode that acts on its own has to be turned on each time.
+- **A queue you can actually manage.** Every queued line now has its own **✕**,
+  so you can remove *any* item — previously the only way out was ↑, which
+  hijacked your input and could only ever reach the newest row, leaving item 1
+  of 3 stuck. `/queue drop N` and `/queue edit N` do the same from the keyboard
+  when your terminal reports no mouse. Editing an item *removes* it from the
+  queue as it moves into your input, so a line can never both sit in the queue
+  and still fire.
+- **Version badge, bottom-right of the window.** Pinned to the corner of the
+  whole window rather than floating inside the toolbar's content. On a narrow
+  terminal the badge is dropped instead of truncating real information.
+- **A live-session indicator that keeps telling you the truth.** The old boot
+  note fired once and scrolled away. The toolbar now shows "● live",
+  "● live · needs approval" or "○ N elsewhere", refreshed every 30 seconds from
+  what the server actually reports — and it stays empty when nothing is
+  running, so an idle dock gains no permanent noise.
+- **✕, Ctrl+W and `/close` all really do close a tab** — they always shared one
+  teardown path; what was missing was saying so, and the busy-close note now
+  names all three ways out.
+- Fixed two latent crashes that would only have fired on a click (a queue panel
+  and a row renderer were each used without being imported).
+
+## 0.3.36
+
+Write on more than one line, and see what a session actually costs.
+
+- **New line inside your prompt.** Press **Alt+Enter** — or **Shift+Enter** on
+  a modern terminal, or **Ctrl+J** anywhere at all — to add a line without
+  sending. Enter still sends, exactly as before. Three chords because no single
+  one is available in every terminal: whichever your setup supports, one of
+  them works. Continuation lines are marked with a dim ┊ gutter, so a
+  half-written message never looks like something already sent. Pasting
+  multi-line text now keeps its line breaks instead of firing off each line.
+- **Spend is visible from every tab.** The status line at the bottom shows the
+  tokens and credits used in this session, in every tab. Home — which has no
+  session of its own — shows the running TOTAL across all your open tabs, both
+  in its status line and in the Wallet tile ("spent this session").
+- **Version and freshness, bottom right of Home.** Your Webbee version sits in
+  the bottom-right corner. It says "up to date" only when we actually managed
+  to check; when we could not reach the release server it shows the plain
+  version rather than a reassurance we cannot back up. A newer release is
+  called out in bee-yellow with the version to upgrade to.
+- **`/login` now works on Home.** Previously `/login`, `/logout`, `/sessions`,
+  `/logout-others` and `/cost` only worked in a session tab, which made no
+  sense — they act on your account, not on a session. They all work on Home
+  now, and Home shows a "Sign in to Imperal" button when you are signed out
+  instead of a blank space. `/cost` on Home reports the whole session's total.
+- `/help` lists the keyboard shortcuts, including the new-line chords.
+
 ## 0.3.35
 
 Reliability and speed of the terminal itself.

{webbee-0.3.35 → webbee-0.3.37}/PKG-INFO

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

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

webbee-0.3.37/src/webbee/__init__.py

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

{webbee-0.3.35 → webbee-0.3.37}/src/webbee/active_sessions.py

@@ -39,6 +39,85 @@ async def fetch_active_sessions(cfg, token_provider, *, client=None) -> list[dic
         return []
 
 
+def live_session_ids(sessions: list[dict]) -> set:
+    """PURE. The set of session ids the gateway currently reports as RUNNING.
+    One helper so the tab-restore reconciliation and the status indicator read
+    liveness from the SAME shape (0.3.37)."""
+    return {str(s.get("session_id") or "") for s in (sessions or [])
+            if str(s.get("session_id") or "")}
+
+
+def session_indicator(sessions: list[dict], repo_key: str) -> str:
+    """PURE. The PERSISTENT live-session indicator for the toolbar (0.3.37).
+
+    Before this, a running Temporal workflow was mentioned exactly once, in a
+    boot note that scrolled away -- so after an accidental exit and reopen the
+    terminal silently re-attached with nothing on screen ever confirming that
+    it had seen a running session, or that one existed at all.
+
+    Returns a SHORT string for the status line, or "" when there is nothing
+    to say (no running sessions at all -- silence is correct then, the dock
+    must not grow permanent noise):
+      * this repo has a live session      -> "● live"
+      * ...and it is parked on an approval -> "● live · needs approval"
+      * only OTHER repos have live ones    -> "○ 2 elsewhere"
+    Honest by construction: it reports what the gateway's Temporal listing
+    actually says, never a guess.
+    """
+    suffix = f"-r{repo_key}"
+    own, own_parked, others = False, False, 0
+    for s in (sessions or []):
+        sid = str(s.get("session_id") or "")
+        if not sid:
+            continue
+        if sid.endswith(suffix):
+            own = True
+            if s.get("pending_consent"):
+                own_parked = True
+        else:
+            others += 1
+    if own:
+        return "● live · needs approval" if own_parked else "● live"
+    if others:
+        return f"○ {others} elsewhere"
+    return ""
+
+
+def plan_tab_restore(saved: list, sessions: list[dict]) -> list:
+    """PURE. Reconcile the REMEMBERED tab layout (tab_store.load_tabs) against
+    the sessions Temporal reports as Running, and decide per tab what reopening
+    it means (0.3.37).
+
+    Each returned dict is the saved record plus:
+      * `attach`: True  -> its workflow is STILL RUNNING; the tab must re-attach
+                           and pick the live run up where it left off.
+        `attach`: False -> nothing is running under that id any more; restore
+                           the tab's state (label/mode/draft) only.
+      * `pending_consent`: carried through from the live listing so a restored
+        tab can immediately show it is parked on an approval.
+
+    A saved tab with no session_id is legal (a tab you never sent anything in)
+    and simply restores as state-only. Never raises; unknown/extra keys on the
+    saved record are ignored rather than trusted.
+    """
+    live = {}
+    for s in (sessions or []):
+        sid = str(s.get("session_id") or "")
+        if sid:
+            live[sid] = s
+    out = []
+    for rec in (saved or []):
+        if not isinstance(rec, dict):
+            continue
+        sid = str(rec.get("session_id") or "")
+        s = live.get(sid)
+        item = dict(rec)
+        item["attach"] = bool(sid and s is not None)
+        item["pending_consent"] = bool((s or {}).get("pending_consent"))
+        out.append(item)
+    return out
+
+
 def boot_reattach_notice(sessions: list[dict], repo_key: str) -> list[str]:
     """Decide what, if anything, to tell the user about their OTHER running
     sessions once THIS terminal's own boot replay has finished. `sessions`

{webbee-0.3.35 → webbee-0.3.37}/src/webbee/commands.py

@@ -23,7 +23,12 @@ _HELP = """Commands:
   /sessions revoke <#>   revoke a session by its number
   /logout-others     sign out every session except this one
   /notify [tg|panel|both|off]   mirror this session to Telegram/panel & steer it back
-  /exit  (=/quit)    quit"""
+  /exit  (=/quit)    quit
+
+Keys:
+  Alt+↵ (or Shift+↵, or Ctrl+J)   new line in the prompt — Enter still sends
+  Shift+TAB          switch mode        Ctrl+T   new tab
+  Alt+№              switch to tab №    Ctrl+W   close tab"""
 
 
 @dataclass(frozen=True)
@@ -106,6 +111,23 @@ def dispatch(line: str, ctx: CommandContext) -> SlashResult:
         # same way /status reads session state); the repl clears the actual
         # deque on action="queue_clear" — the message here already carries
         # the honest drop count.
+        # 0.3.37: drop/edit ONE queued item by its 1-based /queue number --
+        # the KEYBOARD twin of the panel's per-row ✕ and click-to-edit, so
+        # managing a 3-deep queue works on terminals with no mouse reporting
+        # (tmux without mouse on, restrictive SSH clients) too. The repl owns
+        # the actual deque mutation; this layer only validates + routes.
+        if args and args[0].lower() in ("drop", "remove", "rm", "edit"):
+            verb = "queue_drop" if args[0].lower() != "edit" else "queue_edit"
+            if len(args) < 2:
+                return SlashResult(handled=True, action="queue",
+                                   message=f"Usage: /queue {args[0].lower()} <number> "
+                                           f"(see /queue for the numbers).")
+            raw = args[1]
+            if not raw.isdigit() or int(raw) < 1 or int(raw) > len(ctx.queued):
+                return SlashResult(handled=True, action="queue",
+                                   message=(f"No queued item #{raw}. "
+                                            f"Queue holds {len(ctx.queued)}."))
+            return SlashResult(handled=True, action=verb, arg=str(int(raw)))
         if args and args[0].lower() == "clear":
             n = len(ctx.queued)
             return SlashResult(handled=True, action="queue_clear",
@@ -117,7 +139,8 @@ def dispatch(line: str, ctx: CommandContext) -> SlashResult:
         lines = "\n".join(f"  {i}. {t}" for i, t in enumerate(ctx.queued, 1))
         return SlashResult(handled=True, action="queue",
                            message=(f"Queued ({len(ctx.queued)}) — runs in order, "
-                                    f"one per finished turn:\n{lines}"))
+                                    f"one per finished turn:\n{lines}\n"
+                                    f"  /queue drop <n> · /queue edit <n> · /queue clear"))
     if cmd == "/steps":
         if args:
             return SlashResult(handled=True, action="step_detail", arg=args[0])

{webbee-0.3.35 → webbee-0.3.37}/src/webbee/home.py

@@ -181,13 +181,17 @@ async def fill_home(slot, *, cfg, token_provider, slots, account_fetcher,
         try:
             from pathlib import Path
 
-            from webbee.update import check_for_update, default_fetch
+            from webbee.update import check_update_status, default_fetch
             cache = Path(os.path.expanduser("~/.cache/webbee/update.json"))
-            data.update_notice = await asyncio.to_thread(
-                check_for_update, version, cache_path=cache, now=time.time(),
-                fetch=default_fetch) or ""
+            # 0.3.36: the (notice, checked) variant -- Home's version badge
+            # only claims "up to date" when the check actually resolved a
+            # latest version; offline shows the bare version, no false claim.
+            data.update_notice, data.update_checked = await asyncio.to_thread(
+                check_update_status, version, cache_path=cache, now=time.time(),
+                fetch=default_fetch)
         except Exception:
             data.update_notice = ""
+            data.update_checked = False
         _repaint()
     finally:
         slot._last_fill = time.monotonic()

{webbee-0.3.35 → webbee-0.3.37}/src/webbee/home_view.py

@@ -64,6 +64,9 @@ class HomeData:
     endpoint: str = ""
     version: str = ""
     update_notice: str = ""
+    # 0.3.36: did the freshness check actually COMPLETE? False = we could not
+    # reach PyPI (offline/timeout), so the footer must not claim "up to date".
+    update_checked: bool = False
     notice: str = ""             # transient one-line note (top-up/security URL)
 
 
@@ -90,6 +93,11 @@ class HomeActions:
     set_new_tab_mode: "Callable[[str], None]"
     top_up: "Callable[[], None]"
     open_security_docs: "Callable[[], None]"
+    # 0.3.36 -- signing in is now possible FROM Home (/login was un-gated), so
+    # the dashboard offers it as a real action instead of leaving a bare "…"
+    # where the account should be. Optional: None -> the item is not offered
+    # (every pre-0.3.36 caller/test keeps working unchanged).
+    sign_in: "Callable[[], None] | None" = None
 
 
 class HomeModel:
@@ -159,11 +167,64 @@ def _cycle(options, current: str, delta: int) -> str:
     return options[(i + delta) % len(options)]
 
 
+def version_badge(version: str, update_notice: str = "", checked: bool = True) -> "tuple[str, str]":
+    """(text, style_class) for Home's bottom-right version badge (0.3.36).
+
+    THREE honest states, never a fake reassurance:
+      * a newer release is known   -> "v0.3.35 → 0.3.36 available" (accent)
+      * checked, nothing newer     -> "v0.3.36 · up to date"       (dim)
+      * not checked (offline/first run, `checked=False`) -> "v0.3.36"
+        with NO freshness claim at all -- we do not say "up to date" when we
+        could not reach PyPI.
+
+    `update_notice` is `update.check_for_update`'s own sentence; the newer
+    version is parsed out of it for the compact badge and the full upgrade
+    command stays in the Settings tile, so the footer never wraps.
+    """
+    v = (version or "").strip()
+    vtxt = f"v{v}" if v else "v?"
+    notice = (update_notice or "").strip()
+    if notice:
+        latest = ""
+        for tok in notice.replace("—", " ").split():
+            if tok.startswith("v") and tok[1:2].isdigit():
+                latest = tok[1:]
+        return ((f"{vtxt} → {latest} available" if latest else f"{vtxt} · update available"),
+                "class:home.update")
+    if checked:
+        return (f"{vtxt} · up to date", "class:home.fresh")
+    return (vtxt, "class:home.dim")
+
+
 def two_column(width: int, threshold: int = 100) -> bool:
     """Wide terminal -> You + Wallet render side-by-side; narrow -> stacked."""
     return width >= threshold
 
 
+def session_totals(slots) -> "tuple[int, int]":
+    """(tokens, credits) summed across EVERY open session tab (0.3.36).
+
+    Home has no sink of its own, so "what has this session cost me?" can only
+    be answered by adding up the live per-tab counters. Pure + total: any slot
+    whose sink is missing or whose status() misbehaves contributes 0 rather
+    than breaking the toolbar, and Home's own sink-less slot is skipped
+    naturally (no sink -> no numbers). Reuses tab_rows so the numbers on Home
+    and in the toolbar can never disagree.
+    """
+    tokens = credits = 0
+    try:
+        rows = tab_rows(slots)
+    except Exception:
+        return (0, 0)
+    for r in rows:
+        try:
+            tokens += int(r.tokens or 0)
+            credits += int(r.credits or 0)
+        except (TypeError, ValueError):
+            pass
+    return (tokens, credits)
+
+
 def tab_rows(slots) -> "list[TabRow]":
     """PURE transform of the live SlotManager into Home's per-tab rows
     (session tabs only -- Home never lists itself). Per-tab spend comes from
@@ -197,6 +258,16 @@ def build_home_model(data: "HomeData", tabs: "list[TabRow]",
     enabled (they need no live session)."""
     items: "list[ActionItem]" = []
 
+    # Signed out? Then signing in is THE next step -- offer it first, before
+    # anything that would just fail without an account (0.3.36).
+    acct = getattr(data, "account", None)
+    signed_in = bool(getattr(acct, "signed_in", False)) if acct is not None else False
+    if not signed_in and actions.sign_in is not None:
+        items.append(ActionItem(
+            id="sign-in", label="→ Sign in to Imperal",
+            hint="sign in with your browser (same as typing /login)",
+            activate=actions.sign_in))
+
     items.append(ActionItem(
         id="new-session", label="+ New session",
         hint="open a new session tab (Ctrl+T)",
@@ -489,6 +560,13 @@ class HomeView:
             a = self.data.account
             L = [hdr("You")]
             if a is None or not getattr(a, "signed_in", False):
+                # Not signed in (or not fetched yet): say so plainly and offer
+                # the fix right here (0.3.36) instead of an opaque "…".
+                if "sign-in" in by_id:
+                    it = by_id["sign-in"]
+                    return L + [[("class:home.dim", "  not signed in")],
+                                [("class:home.dim", "  "), act(it, "→ Sign in to Imperal")],
+                                [("class:home.dim", "  or type /login")]]
                 return L + [[("class:home.dim", "  …")]]
             nick = getattr(a, "nickname", "") or ""
             L.append([("class:home.value", f"  @{nick}" if nick else "  (no nickname)")])
@@ -516,7 +594,16 @@ class HomeView:
                 L.append([("class:home.dim", "  credits —")])
             else:
                 cap = f" / {_fmt_tokens(w.cap)}" if w.cap else ""
-                L.append([("class:home.value", f"  {_fmt_tokens(w.balance)}{cap} credits")])
+                L.append([("class:home.value", f"  {_fmt_tokens(w.balance)}{cap} credits"),
+                          ("class:home.dim", "  left")])
+            # This session's TOTAL spend across every open tab (0.3.36) --
+            # Home is the summary page, so the figure belongs here and not
+            # only in each tab's own toolbar. Same `session_totals` the
+            # toolbar uses, so the two can never disagree.
+            stk, scr = session_totals(self.slots)
+            L.append([("class:home.dim", "  spent this session  "),
+                      ("class:home.spend", f"{_fmt_tokens(scr)} credits"),
+                      ("class:home.dim", f"  ({_fmt_tokens(stk)} tokens)")])
             it = by_id["top-up"]
             L.append([("class:home.dim", "  "), act(it, "Top up credits")])
             return L
@@ -594,9 +681,22 @@ class HomeView:
             L = [[("", "")], [("class:home.hint", f"  {hint}")]]
             if self.data.notice:
                 L.append([("class:home.dim", f"  {self.data.notice}")])
-            L.append([("class:home.dim",
-                       "  ↑↓ move · ↵ open · ←→ change "
-                       "· Ctrl+T new tab · Alt+N switch")])
+            # Key legend on the LEFT, version badge hard-right on the SAME row
+            # (0.3.36) -- the bottom-right corner of Home, as asked. When the
+            # window is too narrow to hold both, the badge drops to its own
+            # right-aligned row instead of being truncated.
+            keys = ("  ↑↓ move · ↵ open · ←→ change "
+                    "· Alt+↵ newline · Ctrl+T new tab · Alt+N switch")
+            btxt, bstyle = version_badge(self.data.version, self.data.update_notice,
+                                         checked=self.data.update_checked)
+            pad = width - len(keys) - len(btxt) - 2
+            if pad >= 1:
+                L.append([("class:home.dim", keys), ("", " " * pad),
+                          (bstyle, btxt), ("", "  ")])
+            else:
+                L.append([("class:home.dim", keys)])
+                rpad = max(0, width - len(btxt) - 2)
+                L.append([("", " " * rpad), (bstyle, btxt), ("", "  ")])
             return L
 
         # No center title — the tab bar's ◆ Home chip already names the tab,

{webbee-0.3.35 → webbee-0.3.37}/src/webbee/queue_panel.py

@@ -68,6 +68,43 @@ def pull_item(pending, buf, index: int):
     return item
 
 
+def drop_item(pending, index: int):
+    """The ONE queue-REMOVE implementation (0.3.37) — serves the per-row ✕ in
+    the panel. Deletes pending[index] WITHOUT touching the input buffer, so
+    removing item #1 of 3 no longer forces you to pull it into the input just
+    to get rid of it (before this, the only exit from the queue was
+    `pull_item`, which is edit-the-line, hijacks the buffer and — bound to ↑ —
+    only ever reached the NEWEST row).
+
+    Guards mirror `pull_item`: a stale index (the queue drained between render
+    and click) is ignored rather than raising or eating the wrong row. Returns
+    the removed item, or None when nothing was removed.
+    """
+    if not (0 <= index < len(pending)):
+        return None
+    item = pending[index]
+    del pending[index]
+    return item
+
+
+def _drop_handler(drop, index: int, forward=None):
+    """One row's ✕ mouse handler: MOUSE_UP removes THAT queued item via
+    `drop(index)`. Same event discipline as `_item_handler` (MOUSE_UP only,
+    `forward` gets first refusal so a drag released here is not mistaken for
+    a click) — the difference is purely WHICH action fires, so a ✕ click can
+    never be confused with the row-body click that pulls for editing.
+    """
+    def _h(mouse_event):
+        from prompt_toolkit.mouse_events import MouseEventType
+        if forward is not None and forward(mouse_event):
+            return None
+        if mouse_event.event_type == MouseEventType.MOUSE_UP:
+            drop(index)
+            return None
+        return NotImplemented
+    return _h
+
+
 def _item_handler(pull, index: int, forward=None):
     """One row's mouse handler: MOUSE_UP (a click, not a drag/press) pulls
     THAT queued item into the input via `pull(index)`; every other event
@@ -109,7 +146,7 @@ def _toggle_handler(toggle, forward=None):
 
 def queue_fragments(pending, pull=None, width: int = 0, remote=None,
                      collapsed=False, toggle=None, max_items=QP_MAX_ITEMS,
-                     forward=None):
+                     forward=None, drop=None):
     """PURE builder: the panel as prompt_toolkit formatted text, re-invoked
     every redraw (same live mechanics as the toolbar) so every queue
     add/edit/drain shows at once. Layout, top→bottom = drain order (FIFO —
@@ -159,7 +196,9 @@ def queue_fragments(pending, pull=None, width: int = 0, remote=None,
     if collapsed:
         return frags
     if n:
-        frags.append(("class:qp.item", " · ↑ edit last · click to edit"))
+        hint = (" · ↑ edit last · click to edit · ✕ remove" if drop is not None
+                else " · ↑ edit last · click to edit")
+        frags.append(("class:qp.item", hint))
     rstart = max(0, len(rem) - max_items)
     if rstart:
         frags.append(("class:qp.remote", f"\n   … +{rstart} more"))
@@ -177,9 +216,17 @@ def queue_fragments(pending, pull=None, width: int = 0, remote=None,
         frags.append(("class:qp.item", f"\n   … +{start} more"))
     for i in range(start, n):
         style = "class:qp.last" if i == n - 1 else "class:qp.item"
-        row = "\n   " + one_line(items[i], width - 4 if width > 0 else 0)
+        # 0.3.37: reserve the ✕ column so the row text truncates BEFORE the
+        # button rather than shoving it off-screen on a narrow terminal.
+        avail = (width - 4 - (2 if drop is not None else 0)) if width > 0 else 0
+        row = "\n   " + one_line(items[i], avail)
         if pull is None:
             frags.append((style, row))
         else:
             frags.append((style, row, _item_handler(pull, i, forward)))
+        if drop is not None:
+            # Its OWN fragment + OWN handler: clicking ✕ removes the item,
+            # clicking the row body still pulls it for editing. Two adjacent
+            # targets, zero ambiguity.
+            frags.append(("class:qp.drop", " ✕", _drop_handler(drop, i, forward)))
     return frags