webbee 0.3.33__tar.gz → 0.3.34__tar.gz

{webbee-0.3.33 → webbee-0.3.34}/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 0.3.34
+
+Paste images with Ctrl+V. Copy a screenshot (or any image) and press Ctrl+V in
+a session tab — Webbee Code uploads it and drops a reference into your prompt,
+so the next thing you ask can be about that image. Text on the clipboard
+pastes inline. Nothing is sent until you send your message; if image upload
+isn't available the image is saved locally and referenced by path.
+
 ## 0.3.33
 
 Performance.

{webbee-0.3.33 → webbee-0.3.34}/PKG-INFO

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

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

webbee-0.3.34/src/webbee/__init__.py

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

webbee-0.3.34/src/webbee/clipboard_read.py

@@ -0,0 +1,154 @@
+"""Read the OS clipboard OUT-OF-BAND for Ctrl+V paste (W3 Wave A).
+
+A terminal's bracketed paste is text-only — a clipboard IMAGE never reaches the
+app that way — so an image must be pulled from the OS clipboard via the
+platform tool. Same discipline as `clipboard.py` (copy-out): `shutil.which`-
+gated, bounded timeout, output CAPTURED so it never inherits the dock's tty
+(the 0.3.32 lesson: a chatty child scrambles the full-screen renderer), and it
+NEVER raises. macOS + Linux are the verified paths; Windows is best-effort and
+UNVERIFIED (no Windows host to test on) — it fails soft to None."""
+from __future__ import annotations
+
+import shutil
+import subprocess
+import sys
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class ClipboardItem:
+    kind: str          # "image" | "text"
+    data: object       # bytes (PNG) for image, str for text
+    name: str = ""     # suggested filename for an image
+    mime: str = ""
+
+
+def _run(cmd):
+    """Captured, bounded, never-raises subprocess. `capture_output=True` keeps
+    stdout/stderr OFF the dock's tty. Returns CompletedProcess or None."""
+    try:
+        return subprocess.run(cmd, capture_output=True, timeout=2)
+    except Exception:
+        return None
+
+
+def _read_via_tempfile(argv_for_path) -> "bytes | None":
+    """Run a tool that WRITES a PNG to a temp path (osascript / PowerShell),
+    then read+delete it. `argv_for_path(path)` returns the argv. Never raises."""
+    import os
+    import tempfile
+    fd, path = tempfile.mkstemp(suffix=".png")
+    os.close(fd)
+    try:
+        p = _run(argv_for_path(path))
+        if p is not None and p.returncode == 0 and os.path.getsize(path) > 0:
+            with open(path, "rb") as f:
+                return f.read() or None
+        return None
+    except Exception:
+        return None
+    finally:
+        try:
+            os.remove(path)
+        except OSError:
+            pass
+
+
+def _mac_image() -> "bytes | None":
+    if shutil.which("pngpaste"):
+        p = _run(["pngpaste", "-"])
+        if p is not None and p.returncode == 0 and p.stdout:
+            return p.stdout
+    if not shutil.which("osascript"):
+        return None
+    # osascript returns non-zero when the clipboard holds no «class PNGf» image.
+    def _argv(path):
+        script = ('set p to (POSIX file "%s")\n'
+                  'set d to (the clipboard as «class PNGf»)\n'
+                  'set fh to open for access p with write permission\n'
+                  'write d to fh\nclose access fh' % path)
+        return ["osascript", "-e", script]
+    return _read_via_tempfile(_argv)
+
+
+def _linux_image() -> "bytes | None":
+    if shutil.which("wl-paste"):
+        types = _run(["wl-paste", "--list-types"])
+        if types is not None and types.returncode == 0 and b"image/png" in (types.stdout or b""):
+            p = _run(["wl-paste", "--type", "image/png"])
+            if p is not None and p.returncode == 0 and p.stdout:
+                return p.stdout
+    if shutil.which("xclip"):
+        tgt = _run(["xclip", "-selection", "clipboard", "-t", "TARGETS", "-o"])
+        if tgt is not None and tgt.returncode == 0 and b"image/png" in (tgt.stdout or b""):
+            p = _run(["xclip", "-selection", "clipboard", "-t", "image/png", "-o"])
+            if p is not None and p.returncode == 0 and p.stdout:
+                return p.stdout
+    return None
+
+
+def _windows_image() -> "bytes | None":
+    # UNVERIFIED (no Windows host). Best-effort; fail-soft to None.
+    if not shutil.which("powershell"):
+        return None
+
+    def _argv(path):
+        ps = ("Add-Type -AssemblyName System.Windows.Forms;"
+              "$i=[System.Windows.Forms.Clipboard]::GetImage();"
+              "if($i){$i.Save('%s')}" % path.replace("\\", "\\\\"))
+        return ["powershell", "-NoProfile", "-Command", ps]
+    return _read_via_tempfile(_argv)
+
+
+def read_clipboard_image() -> "bytes | None":
+    """Raw PNG bytes on the clipboard, or None. Platform-dispatched, captured
+    (tty-safe), never raises."""
+    try:
+        if sys.platform == "darwin":
+            return _mac_image()
+        if sys.platform == "win32":
+            return _windows_image()
+        return _linux_image()
+    except Exception:
+        return None
+
+
+def _text_cmd() -> "list[str] | None":
+    if sys.platform == "darwin":
+        return ["pbpaste"] if shutil.which("pbpaste") else None
+    if shutil.which("wl-paste"):
+        return ["wl-paste", "--no-newline"]
+    if shutil.which("xclip"):
+        return ["xclip", "-selection", "clipboard", "-o"]
+    if sys.platform == "win32" and shutil.which("powershell"):
+        return ["powershell", "-NoProfile", "-Command", "Get-Clipboard"]
+    return None
+
+
+def read_clipboard_text() -> "str | None":
+    """The clipboard's text, or None. Captured (tty-safe), never raises."""
+    cmd = _text_cmd()
+    if cmd is None:
+        return None
+    p = _run(cmd)
+    if p is not None and p.returncode == 0 and p.stdout:
+        try:
+            return p.stdout.decode("utf-8", "replace")
+        except Exception:
+            return None
+    return None
+
+
+def read_clipboard(ts: str) -> "ClipboardItem | None":
+    """One paste's worth of clipboard content: an IMAGE if present (PNG bytes,
+    named `pasted-<ts>.png`), else TEXT, else None. `ts` is a caller-supplied
+    timestamp string for the image name (the dock has no wall-clock in a pure
+    function, so it's passed in)."""
+    img = read_clipboard_image()
+    if img:
+        return ClipboardItem(kind="image", data=img, name=f"pasted-{ts}.png",
+                             mime="image/png")
+    txt = read_clipboard_text()
+    if txt:
+        return ClipboardItem(kind="text", data=txt)
+    return None

{webbee-0.3.33 → webbee-0.3.34}/src/webbee/home_view.py

@@ -368,6 +368,9 @@ class HomeView:
     def flash(self) -> str:
         return self._out.flash()
 
+    def flash_note(self, msg: str, secs: float = 4.0) -> None:
+        self._out.flash_note(msg, secs)
+
     def scroll(self, delta: int) -> None:
         # Wheel (via the control) and PageUp/PageDown (tui routes here) move the
         # top visible line; clamped so you can't scroll past the ends.

{webbee-0.3.33 → webbee-0.3.34}/src/webbee/intel/watch.py

@@ -11,7 +11,9 @@ def _ignored(path: str) -> bool:
     filter works on Windows too (watchfiles yields backslash paths there --
     unfiltered .git churn re-indexed the repo on every checkpoint)."""
     p = path.replace(os.sep, "/").replace("\\", "/")
-    return "/.git/" in p or "/node_modules/" in p
+    # `.webbee/` = our own per-workspace scratch (pasted images, gitignore) —
+    # never re-index/checkpoint on a paste (W3).
+    return "/.git/" in p or "/node_modules/" in p or "/.webbee/" in p
 
 
 async def watch_workspace(root: str, on_change) -> None:

{webbee-0.3.33 → webbee-0.3.34}/src/webbee/output_pane.py

@@ -335,6 +335,13 @@ class OutputPane:
         import time as _t
         return self.copy_flash if _t.monotonic() < self._flash_until else ""
 
+    def flash_note(self, msg: str, secs: float = 4.0) -> None:
+        """Show a transient toolbar note (paste progress, hints) — same channel
+        as the copy toast, reused so there's one flash mechanism."""
+        import time as _t
+        self.copy_flash = msg
+        self._flash_until = _t.monotonic() + secs
+
     # ---- W2 Task 8: selection capture past the pane's own Window --------
     def forward_mouse(self, ev, clamp: str = "bottom") -> bool:
         """Public seam neighbor windows call FIRST (via `tui._forwarding` /

{webbee-0.3.33 → webbee-0.3.34}/src/webbee/repl.py

@@ -676,6 +676,43 @@ def _schedule_home_refill(slots: SlotManager, idx: int, fill_kwargs: dict, *,
     return True
 
 
+def _save_pasted(workspace: str, name: str, data: bytes) -> str:
+    """Save a pasted image into `<workspace>/.webbee/pasted/<name>` (that dir
+    ships a `.gitignore` of `*` so pasted files never pollute the repo or its
+    shadow-git). Returns the saved path, or "" on any failure. Never raises."""
+    try:
+        base = os.path.join(workspace, ".webbee")
+        pdir = os.path.join(base, "pasted")
+        os.makedirs(pdir, exist_ok=True)
+        gi = os.path.join(base, ".gitignore")
+        if not os.path.exists(gi):
+            with open(gi, "w", encoding="utf-8") as f:
+                f.write("*\n")
+        path = os.path.join(pdir, name)
+        with open(path, "wb") as f:
+            f.write(data)
+        return path
+    except Exception:
+        return ""
+
+
+def _extract_file_id(resp) -> str:
+    """Pull `file_id` from a file-reader `receive_files` response. Canon: it
+    lives at `data.items[].file_id` (== `.id`), NOT `data.received` (the panel's
+    Round-3 lesson). Handles dict + object shapes; "" if absent."""
+    try:
+        data = resp.get("data") if isinstance(resp, dict) else getattr(resp, "data", None)
+        items = data.get("items") if isinstance(data, dict) else getattr(data, "items", None)
+        if items:
+            it = items[0]
+            if isinstance(it, dict):
+                return str(it.get("file_id") or it.get("id") or "")
+            return str(getattr(it, "file_id", "") or getattr(it, "id", "") or "")
+    except Exception:
+        pass
+    return ""
+
+
 async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None, read_line=input,
                    agent_factory=None, auth=None, account_fetcher=None,
                    sessions_client=None, intel_factory=None, shadow_factory=None) -> None:
@@ -1337,6 +1374,32 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
                         from prompt_toolkit.application import get_app
                         get_app().exit()
 
+                async def _on_paste(ws: str, name: str, data: bytes) -> str:
+                    # W3 Wave A: save the pasted image into the tab's workspace
+                    # then upload it through the SAME file-reader door the panel
+                    # and Telegram use; return the reference to drop into the
+                    # task. Degrades honestly on 402 / no cloud (local path +
+                    # note). Never raises.
+                    import base64
+                    saved = _save_pasted(ws, name, data)
+                    try:
+                        from imperal_mcp.client import ImperalClient
+                        client = ImperalClient(cfg, token_provider)
+                        b64 = base64.b64encode(data).decode("ascii")
+                        resp = await client.run_tool(
+                            "file-reader", "receive_files",
+                            {"files": [{"name": name, "mime_type": "image/png",
+                                        "data_base64": b64}]})
+                        fid = _extract_file_id(resp)
+                        if fid:
+                            return f"📎 {name} (file_id={fid})"
+                    except Exception:
+                        pass
+                    if saved:
+                        return (f"📎 {name} — saved to {saved}; a file-reader "
+                                "plan is needed to send it to the model")
+                    return f"📎 {name} — could not upload"
+
                 try:
                     ok = await tui.run_session(
                         slots=slots, on_line=_on_line, on_cycle=_cycle,
@@ -1359,6 +1422,7 @@ async def run_repl(cfg, mode: str = "default", *, once: bool = False, sink=None,
                             spawn_poller=_spawn_slot_poller),
                         on_switch=lambda idx: _schedule_home_refill(slots, idx, home_fill_kwargs),
                         on_new=lambda: _open_new_tab(),
+                        on_paste=_on_paste,
                     )
                 finally:
                     _cancel_background()

{webbee-0.3.33 → webbee-0.3.34}/src/webbee/tui.py

@@ -534,7 +534,7 @@ def _restore_draft(buf, slot) -> None:
 async def run_session(*, slots, on_line, on_cycle, steps_nav=None,
                       stop_turn=None, queued_run=None, inject=None,
                       home_input=None, cancel_slot=None, ui_hooks=None,
-                      on_switch=None, on_new=None) -> bool:
+                      on_switch=None, on_new=None, on_paste=None) -> bool:
     """The full-screen dock: EVERYTHING visible resolves `slots.active()` AT
     CALL TIME (W4a Task 3 — the single most structural change of the
     multisession-tabs wave: no more one session's objects captured once at
@@ -849,6 +849,49 @@ async def run_session(*, slots, on_line, on_cycle, steps_nav=None,
         # Alt+1-style switch (footer legend reminds muscle-memory users).
         _new_tab_click()
 
+    @kb.add("c-v")
+    def _paste_key(event):
+        # 0.3.34 (W3 Wave A): Ctrl-V pastes the OS clipboard. An IMAGE is read
+        # OUT-OF-BAND (a terminal's bracketed paste is text-only), then saved +
+        # uploaded via the file-reader door (repl's on_paste) and its reference
+        # dropped into the input; a text clipboard is inserted inline. Normal
+        # text paste (Cmd-V / Ctrl-Shift-V → bracketed paste) is a DIFFERENT
+        # key and is unaffected. Home has no workspace/agent → guide, not crash.
+        import time as _t
+        from webbee.clipboard_read import read_clipboard
+        slot = _a()
+        pane = _pane()
+        if on_paste is None or slot.kind == "home" or not getattr(slot, "workspace", ""):
+            pane.flash_note("📎 open a session tab to paste a file")
+            event.app.invalidate()
+            return
+        item = read_clipboard(_t.strftime("%Y%m%d-%H%M%S", _t.gmtime()))
+        if item is None:
+            pane.flash_note("clipboard is empty")
+            event.app.invalidate()
+            return
+        if item.kind == "text":
+            buf.insert_text(item.data)
+            return
+        pane.flash_note(f"📎 uploading {item.name}…", secs=30.0)
+        event.app.invalidate()
+
+        async def _do_paste():
+            ref = ""
+            try:
+                ref = await on_paste(slot.workspace, item.name, item.data)
+            except Exception:
+                ref = ""
+            if ref:
+                sep = "" if (not buf.text or buf.text.endswith(" ")) else " "
+                buf.insert_text(sep + ref + " ")
+                pane.flash_note(f"📎 {item.name}")
+            else:
+                pane.flash_note("📎 paste failed")
+            event.app.invalidate()
+
+        event.app.create_background_task(_do_paste())
+
     def _alt_digit_handler(d: int):
         def _h(event):
             _switch_to(d)

webbee-0.3.34/tests/test_clipboard_read.py

@@ -0,0 +1,84 @@
+import subprocess
+import sys
+
+import webbee.clipboard_read as cr
+
+
+class _CP:
+    def __init__(self, rc=0, out=b""):
+        self.returncode = rc
+        self.stdout = out
+
+
+def test_run_captures_output_tty_safe(monkeypatch):
+    # The 0.3.32 lesson: clipboard subprocesses must NOT inherit the dock tty.
+    seen = {}
+
+    def fake(cmd, **kw):
+        seen.update(kw)
+        return _CP(0, b"x")
+
+    monkeypatch.setattr(subprocess, "run", fake)
+    cr._run(["echo"])
+    assert seen.get("capture_output") is True
+    assert seen.get("timeout") == 2
+
+
+def test_run_never_raises(monkeypatch):
+    monkeypatch.setattr(subprocess, "run", lambda *a, **k: (_ for _ in ()).throw(RuntimeError()))
+    assert cr._run(["x"]) is None
+
+
+def test_mac_image_via_pngpaste(monkeypatch):
+    monkeypatch.setattr(sys, "platform", "darwin")
+    monkeypatch.setattr(cr.shutil, "which", lambda n: "/p" if n == "pngpaste" else None)
+    monkeypatch.setattr(subprocess, "run", lambda cmd, **k: _CP(0, b"\x89PNGdata"))
+    assert cr.read_clipboard_image() == b"\x89PNGdata"
+
+
+def test_image_none_when_no_tool(monkeypatch):
+    monkeypatch.setattr(sys, "platform", "darwin")
+    monkeypatch.setattr(cr.shutil, "which", lambda n: None)
+    assert cr.read_clipboard_image() is None
+
+
+def test_linux_image_requires_png_in_targets(monkeypatch):
+    monkeypatch.setattr(sys, "platform", "linux")
+    monkeypatch.setattr(cr.shutil, "which", lambda n: "/x" if n == "xclip" else None)
+
+    def fake(cmd, **k):
+        if "TARGETS" in cmd:
+            return _CP(0, b"TARGETS\nimage/png\nUTF8_STRING")
+        return _CP(0, b"PNGDATA")
+
+    monkeypatch.setattr(subprocess, "run", fake)
+    assert cr.read_clipboard_image() == b"PNGDATA"
+
+
+def test_linux_image_none_when_no_png_target(monkeypatch):
+    monkeypatch.setattr(sys, "platform", "linux")
+    monkeypatch.setattr(cr.shutil, "which", lambda n: "/x" if n == "xclip" else None)
+    monkeypatch.setattr(subprocess, "run", lambda cmd, **k: _CP(0, b"TARGETS\nUTF8_STRING"))
+    assert cr.read_clipboard_image() is None
+
+
+def test_read_clipboard_text(monkeypatch):
+    monkeypatch.setattr(sys, "platform", "darwin")
+    monkeypatch.setattr(cr.shutil, "which", lambda n: "/p" if n == "pbpaste" else None)
+    monkeypatch.setattr(subprocess, "run", lambda cmd, **k: _CP(0, b"hello text"))
+    assert cr.read_clipboard_text() == "hello text"
+
+
+def test_read_clipboard_prefers_image_then_text_then_none(monkeypatch):
+    monkeypatch.setattr(cr, "read_clipboard_image", lambda: b"IMG")
+    monkeypatch.setattr(cr, "read_clipboard_text", lambda: "txt")
+    item = cr.read_clipboard("20260721")
+    assert item.kind == "image" and item.data == b"IMG"
+    assert item.name == "pasted-20260721.png" and item.mime == "image/png"
+
+    monkeypatch.setattr(cr, "read_clipboard_image", lambda: None)
+    item = cr.read_clipboard("x")
+    assert item.kind == "text" and item.data == "txt"
+
+    monkeypatch.setattr(cr, "read_clipboard_text", lambda: None)
+    assert cr.read_clipboard("x") is None

{webbee-0.3.33 → webbee-0.3.34}/tests/test_repl.py

@@ -2815,3 +2815,29 @@ def test_remote_mode_flip_targets_polled_slot_not_active(monkeypatch):
     confirm_src = inspect.getsource(repl_mod._confirm_autopilot)
     assert "slots.active()" not in confirm_src
     assert "def _confirm_autopilot(slot" in confirm_src
+
+
+def test_extract_file_id_reads_items_path():
+    # Canon: data.items[].file_id (== .id), NOT data.received.
+    from webbee.repl import _extract_file_id
+    assert _extract_file_id({"data": {"items": [{"file_id": "abc", "id": "xyz"}]}}) == "abc"
+    assert _extract_file_id({"data": {"items": [{"id": "xyz"}]}}) == "xyz"
+    assert _extract_file_id({"data": {"items": []}}) == ""
+    assert _extract_file_id({"data": {}}) == ""
+    assert _extract_file_id({}) == ""
+    assert _extract_file_id(None) == ""
+
+
+def test_save_pasted_writes_file_and_gitignore(tmp_path):
+    import os as _os
+    from webbee.repl import _save_pasted
+    p = _save_pasted(str(tmp_path), "pasted-x.png", b"\x89PNG")
+    assert p and _os.path.isfile(p)
+    with open(p, "rb") as f:
+        assert f.read() == b"\x89PNG"
+    assert (tmp_path / ".webbee" / ".gitignore").read_text().strip() == "*"
+
+
+def test_save_pasted_never_raises_on_bad_dir():
+    from webbee.repl import _save_pasted
+    assert _save_pasted("/dev/null/nope", "x.png", b"x") == ""

webbee-0.3.33/src/webbee/__init__.py

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