webbee 0.3.2__tar.gz → 0.3.3__tar.gz

{webbee-0.3.2 → webbee-0.3.3}/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 0.3.3
+
+- Mouse-garbage / dead-keyboard fix (Linux, occasionally macOS): the dock now
+  uses button-event mouse tracking instead of any-event — bare mouse movement
+  no longer floods the terminal with reports that desynced the input parser,
+  typed `35;6;42M…` fragments into the input box and fired phantom Escape
+  presses that silently stopped the running turn. Scroll, click and
+  drag-to-copy work as before. Leftover report fragments are scrubbed from
+  the input, and a phantom Escape during a flood cleans the input instead of
+  killing the turn.
+- Untrusted text (tool output, relayed notes/summaries) is stripped of raw
+  escape/control bytes before rendering, so it can never flip terminal modes.
+
 ## 0.3.2
 
 - Wrapped lines keep their left gutter: a long note / progress / thinking /

{webbee-0.3.2 → webbee-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: webbee
-Version: 0.3.2
+Version: 0.3.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.3.2 → webbee-0.3.3}/pyproject.toml

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

webbee-0.3.3/src/webbee/__init__.py

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

{webbee-0.3.2 → webbee-0.3.3}/src/webbee/render.py

@@ -1,4 +1,5 @@
 import asyncio
+import re
 import time
 
 from rich.console import Console
@@ -20,6 +21,24 @@ def _pad(renderable):
     lines up with the 2-space chrome ('  🐝 Webbee', '  13.9s · …', the ❯ bar)."""
     return Padding(renderable, (0, 0, 0, _GUTTER))
 
+
+# Untrusted content (tool output, kernel-relayed text) must never carry raw
+# escape/control bytes into the terminal: a \x1b[?1003h inside a printed tool
+# summary silently flips the terminal into any-event mouse tracking (the
+# mouse-garbage bug's evil twin); OSC can retitle/exfiltrate. Rich's Text
+# passes raw \x1b through untouched, so we strip at the sink: CSI and OSC
+# sequences whole, then every remaining C0 control byte except \n and \t.
+_CTRL = re.compile(
+    r"\x1b\[[0-9;?]*[ -/]*[@-~]"            # CSI (incl. private modes)
+    r"|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)?"   # OSC (BEL/ST or unterminated)
+    r"|[\x00-\x08\x0b-\x1f\x7f]"             # other C0 + DEL (keeps \t \n)
+)
+
+
+def _clean(s) -> str:
+    """Strip escape sequences + control bytes from untrusted display text."""
+    return _CTRL.sub("", str(s or ""))
+
 _ICON = {"read_file": "📖", "grep": "🔎", "glob": "🗂️", "write_file": "✎",
          "edit_file": "🔧", "bash": "⚡"}
 _BEE = "yellow"       # bee-yellow brand accent — logo / 🐝 / notes / busy dot ONLY
@@ -173,6 +192,7 @@ class RichSink:
 
     def end_turn(self, final_text: str) -> None:
         self._busy = False
+        final_text = _clean(final_text)
         if final_text:
             self.console.print()   # separation before the focus block
             self.console.print(Text("  🐝 Webbee", style=f"bold {_BEE}"))
@@ -192,14 +212,14 @@ class RichSink:
         # _pad (not a "  " prefix) so a wrapped line keeps the gutter — a bare
         # prefix indents only the first visual line and continuations hug the
         # screen edge.
-        self.console.print(_pad(Text(message, style=_BEE)))
+        self.console.print(_pad(Text(_clean(message), style=_BEE)))
         self._nudge()
 
     def user_echo(self, text: str) -> None:
         """Commit the just-sent user message as its own clearly-readable line
         with a background bar (NOT boxed like the live input) so it stands out
         as 'what I sent' in the scrollback."""
-        self.console.print(_pad(Text(" ❯ " + text + " ", style="bold white on grey30")))
+        self.console.print(_pad(Text(" ❯ " + _clean(text) + " ", style="bold white on grey30")))
         self._nudge()
 
     def clear(self) -> None:
@@ -236,11 +256,11 @@ class RichSink:
         mark = "✓" if ok else "✗"
         self.console.print(Text.assemble(
             ("  " + icon + " ", "dim"),
-            (_tool, "dim"),
-            (("  " + arg[:40]) if arg else "", "dim"),
+            (_clean(_tool), "dim"),
+            (("  " + _clean(arg)[:40]) if arg else "", "dim"),
             ("   ", ""),
             (mark + " ", "green" if ok else "red"),
-            (str(summary)[:50], "dim"),
+            (_clean(summary)[:50], "dim"),
         ))
         self._pending = ("", "")
         self._nudge()
@@ -251,8 +271,8 @@ class RichSink:
         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)."""
-        label = f"{app_id}·{tool}" if app_id else tool
-        sal = _salient_arg(args)
+        label = _clean(f"{app_id}·{tool}" if app_id else tool)
+        sal = _clean(_salient_arg(args))
         self.console.print(Text.assemble(("  ? approve ", "yellow"), (label, "dim"),
                                           (("  " + sal[:60]) if sal else "", "dim")))
         fut = self._arm_consent(label, sal)
@@ -324,7 +344,7 @@ class RichSink:
         def _prev(p):
             p = p or {}
             note = f"  (truncated, {p.get('total_bytes', 0)} bytes total)" if p.get("truncated") else ""
-            return (str(p.get("preview", "") or "")[:2000]) + note
+            return (_clean(p.get("preview", ""))[:2000]) + note
 
         mark = "✓" if detail.get("ok") else "✗"
         head = (f"{mark} {detail.get('app_id', '')}·{detail.get('tool', '')}  "
@@ -336,14 +356,14 @@ class RichSink:
 
     def progress(self, text: str) -> None:
         if text:
-            self.console.print(_pad(Text(text, style="dim italic")))
+            self.console.print(_pad(Text(_clean(text), style="dim italic")))
             self._nudge()
 
     def thinking(self, text: str) -> None:
         # System-driven reasoning as a distinct 💭 block — visually apart from the
         # dim `progress` line (which stays reserved for status like low-balance).
         if text:
-            self.console.print(_pad(Text("💭 " + text, style="italic medium_purple3")))
+            self.console.print(_pad(Text("💭 " + _clean(text), style="italic medium_purple3")))
             self._nudge()
 
     def plan_blocked(self, tool: str) -> None:

{webbee-0.3.2 → webbee-0.3.3}/src/webbee/tui.py

@@ -6,6 +6,7 @@ pinned box when the input is empty and no turn is running. Pure helpers
 (next_mode/build_toolbar) are unit-tested; the Application is TTY/headless-
 smoke verified. Grounded in prompt_toolkit 3.0.52."""
 import asyncio
+import re
 
 from webbee.output_pane import OutputPane  # noqa: F401 — re-exported (webbee.tui.OutputPane)
 from webbee.render import _fmt_tokens
@@ -13,6 +14,46 @@ from webbee.render import _fmt_tokens
 _MODES = ("default", "plan", "autopilot")
 _SPINNER = "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏"   # braille frames — animated while a turn runs
 
+# Leaked SGR mouse-report fragments ("<35;6;42M" / "35;6;42M"): under a
+# mouse-move flood the vt100 parser splits sequences at read-chunk boundaries
+# and the printable tail lands in the input buffer as literal text (live on
+# Linux + occasionally macOS, 2026-07-12). Requires the full x;y;btn+M shape —
+# ordinary "a;b;c" text never matches (a literal "35;6;42M" the user typed
+# would be dropped too; accepted, it IS the residue shape).
+_MOUSE_RESIDUE = re.compile(r"(?:\x1b\[)?<?\d{1,4};\d{1,4};\d{1,4}[Mm]")
+
+
+def scrub_mouse_residue(text: str) -> str:
+    """PURE. Drop leaked mouse-report fragments; everything else unchanged."""
+    return _MOUSE_RESIDUE.sub("", text or "")
+
+
+def configure_mouse_modes(output) -> None:
+    """Replace prompt_toolkit's ANY-EVENT mouse tracking (?1003 — every bare
+    mouse move fires a report) with BUTTON-EVENT tracking (?1002 — reports only
+    while a button is held). Wheel scroll, clicks and drag-select all still
+    work; the bare-move flood that desyncs the parser (phantom Escape + report
+    tails typed into the input) disappears at the source. No-op for outputs
+    without write_raw (non-vt100)."""
+    if not hasattr(output, "write_raw"):
+        return
+
+    def _enable():
+        output.write_raw("\x1b[?1000h")   # clicks + wheel
+        output.write_raw("\x1b[?1002h")   # motion ONLY while a button is held
+        output.write_raw("\x1b[?1015h")   # urxvt encoding
+        output.write_raw("\x1b[?1006h")   # SGR encoding
+
+    def _disable():
+        output.write_raw("\x1b[?1002l")
+        output.write_raw("\x1b[?1003l")   # belt & braces: clear any-event too
+        output.write_raw("\x1b[?1000l")
+        output.write_raw("\x1b[?1015l")
+        output.write_raw("\x1b[?1006l")
+
+    output.enable_mouse_support = _enable
+    output.disable_mouse_support = _disable
+
 
 def next_mode(mode: str) -> str:
     try:
@@ -47,11 +88,19 @@ def build_toolbar(mode: str, tokens: int, credits: int, *, busy: bool = False,
              f"   ·   {_fmt_tokens(tokens)} tok · {_fmt_tokens(credits)} credits   ·   Shift + TAB: switch mode")]
 
 
-def _escape_action(sel: dict, turn: dict, is_busy, stop_turn, event) -> None:
+def _escape_action(sel: dict, turn: dict, is_busy, stop_turn, event, buf=None) -> None:
     """Esc key binding (P5g). While a turn is running, STOP it — cancel the LOCAL
     turn task (what actually tears the turn down, same as Ctrl-C) AND ask the
-    server to stop (so it stops spending). While idle, clear the step-selection."""
+    server to stop (so it stops spending). While idle, clear the step-selection.
+
+    Phantom-Esc guard (2026-07-12): a mouse-report flood splits sequences —
+    the ESC arrives as a lone Escape KEY and the tail lands in the input
+    buffer. Residue in the buffer ⇒ this Escape is almost certainly a split
+    report, not the user: clean the buffer and KEEP the turn running."""
     if is_busy():
+        if buf is not None and _MOUSE_RESIDUE.search(buf.text or ""):
+            buf.text = scrub_mouse_residue(buf.text)
+            return
         t = turn.get("task")
         if t is not None and not t.done():
             if stop_turn is not None:
@@ -110,7 +159,7 @@ async def run_session(*, pane, on_line, mode_getter, on_cycle, status,
 
     @kb.add("enter")
     def _enter(event):
-        text = buf.text
+        text = scrub_mouse_residue(buf.text)   # never send leaked mouse reports
         buf.reset()
         if consent_pending():
             resolve_consent(text)              # ICNLI: relay the raw reply verbatim
@@ -161,7 +210,7 @@ async def run_session(*, pane, on_line, mode_getter, on_cycle, status,
 
     @kb.add("escape")
     def _step_clear(event):
-        _escape_action(sel, turn, is_busy, stop_turn, event)
+        _escape_action(sel, turn, is_busy, stop_turn, event, buf=buf)
 
     @kb.add("pageup")
     def _pgup(event):
@@ -218,6 +267,7 @@ async def run_session(*, pane, on_line, mode_getter, on_cycle, status,
     })
     app = Application(layout=Layout(root, focused_element=input_win), key_bindings=kb,
                       full_screen=True, mouse_support=True, style=style)
+    configure_mouse_modes(app.output)   # ?1002 button-event, never ?1003 any-event
 
     async def _ticker():
         # animate the spinner + tick the elapsed clock while a turn runs

{webbee-0.3.2 → webbee-0.3.3}/tests/test_render.py

@@ -340,3 +340,45 @@ def test_user_echo_wraps_with_gutter():
     s.user_echo("please migrate the whole extension to the new backend path "
                 "and make sure nothing regresses while you are at it")
     _assert_gutter(s.console.export_text())
+
+
+# ---- control-byte sanitization of untrusted content (0.3.3) -----------------
+# Tool output / kernel-relayed text must never carry raw ESC sequences into the
+# terminal — \x1b[?1003h in a printed summary would silently flip the user's
+# terminal into any-event mouse tracking (the mouse-garbage bug's evil twin).
+
+_INJ = "ok\x1b[?1003h\x1b]0;pwned\x07 done"
+
+
+def test_note_strips_escape_sequences():
+    s = _sink()
+    s.note(_INJ)
+    out = s.console.export_text()
+    assert "\x1b[?1003h" not in out and "pwned" not in out
+    assert "ok" in out and "done" in out
+
+
+def test_tool_result_strips_escape_sequences():
+    s = _sink()
+    s.tool_start("bash", {"command": "cat file"})
+    s.tool_result("bash", True, _INJ)
+    out = s.console.export_text()
+    assert "\x1b[?1003h" not in out
+    assert "ok" in out
+
+
+def test_end_turn_strips_escape_sequences_keeps_newlines():
+    s = _sink()
+    s.begin_turn()
+    s.end_turn("line one\x1b[?1003h\n\nline two")
+    out = s.console.export_text()
+    assert "\x1b[?1003h" not in out
+    assert "line one" in out and "line two" in out
+
+
+def test_progress_and_thinking_strip_escapes():
+    s = _sink()
+    s.progress(_INJ)
+    s.thinking(_INJ)
+    out = s.console.export_text()
+    assert "\x1b[?1003h" not in out and "pwned" not in out

{webbee-0.3.2 → webbee-0.3.3}/tests/test_tui.py

@@ -327,3 +327,88 @@ def test_interrupt_with_no_running_task_is_a_noop():
 
     assert event.app.background_tasks == []
     assert stop_calls == []
+
+
+# ---- mouse-report flood hardening (0.3.3) ----------------------------------
+# Linux (occasionally macOS) terminals under prompt_toolkit's default
+# mouse_support=True run ANY-EVENT tracking (?1003): every bare mouse move
+# fires an SGR report. Under that flood the vt100 parser splits sequences at
+# read-chunk boundaries — the ESC arrives as a phantom Escape KEY (which used
+# to stop the running turn!) and the tail ("35;6;42M…") lands in the input
+# buffer as literal text.
+
+_GARBAGE = "roo35;6;42M<35;35;46M5;49;46M3M35;71;37M29M5;94;19M5;101;14M4M"
+
+
+def test_scrub_mouse_residue_removes_leaked_reports():
+    from webbee.tui import scrub_mouse_residue
+    out = scrub_mouse_residue(_GARBAGE)
+    assert "42M" not in out and "<35" not in out
+    assert out.startswith("roo")            # non-residue text survives
+
+
+def test_scrub_mouse_residue_keeps_normal_text():
+    from webbee.tui import scrub_mouse_residue
+    for s in ("fix the tests", "a;b;c", "35;6", "надо дочинить endpoint'ы", ""):
+        assert scrub_mouse_residue(s) == s
+
+
+class _FakeOutput:
+    def __init__(self):
+        self.raw = []
+
+    def write_raw(self, s):
+        self.raw.append(s)
+
+
+def test_configure_mouse_modes_button_event_not_any_event():
+    from webbee.tui import configure_mouse_modes
+    out = _FakeOutput()
+    configure_mouse_modes(out)
+    out.enable_mouse_support()
+    joined = "".join(out.raw)
+    assert "\x1b[?1002h" in joined           # drag/wheel/click tracking
+    assert "\x1b[?1003h" not in joined       # NEVER any-event (bare-move flood)
+    out.raw.clear()
+    out.disable_mouse_support()
+    joined = "".join(out.raw)
+    assert "\x1b[?1002l" in joined and "\x1b[?1003l" in joined  # belt & braces
+
+
+def test_configure_mouse_modes_skips_outputs_without_write_raw():
+    from webbee.tui import configure_mouse_modes
+    class _Plain:
+        pass
+    p = _Plain()
+    configure_mouse_modes(p)                 # must not raise, must not add attrs
+    assert not hasattr(p, "enable_mouse_support")
+
+
+class _FakeBuf:
+    def __init__(self, text=""):
+        self.text = text
+
+
+def test_phantom_escape_with_residue_cleans_buffer_not_the_turn():
+    # A mouse-report flood in the input buffer means this Escape is almost
+    # certainly a SPLIT SEQUENCE, not the user — never kill the turn on it.
+    from webbee.tui import _escape_action
+
+    event = _FakeEvent()
+    task = _FakeTask()
+    turn = {"task": task}
+    buf = _FakeBuf("draft " + _GARBAGE)
+    _escape_action({"i": None}, turn, lambda: True, None, event, buf=buf)
+    assert task.cancelled == []              # the turn SURVIVES
+    assert "42M" not in buf.text             # the residue is cleaned
+    assert buf.text.startswith("draft roo")
+
+
+def test_real_escape_with_clean_buffer_still_stops_the_turn():
+    from webbee.tui import _escape_action
+
+    event = _FakeEvent()
+    task = _FakeTask()
+    turn = {"task": task}
+    _escape_action({"i": None}, turn, lambda: True, None, event, buf=_FakeBuf("draft reply"))
+    assert task.cancelled == [1]             # normal Esc behavior unchanged

webbee-0.3.2/src/webbee/__init__.py

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