code-puppy 0.0.612__tar.gz → 0.0.613__tar.gz

{code_puppy-0.0.612 → code_puppy-0.0.613}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.612
+Version: 0.0.613
 Summary: Code generation agent
 Project-URL: repository, https://github.com/mpfaffenberger/code_puppy
 Project-URL: HomePage, https://github.com/mpfaffenberger/code_puppy

{code_puppy-0.0.612 → code_puppy-0.0.613}/code_puppy/agents/_key_listeners.py

@@ -533,7 +533,18 @@ def _coalesce_paste_burst(items: list) -> Optional[str]:
         return None
     if any(kind != "char" for kind, _ in items):
         return None
-    return "".join(value for _, value in items)
+    payload = "".join(value for _, value in items)
+    if "\x1b" in payload and _PASTE_OPEN not in payload and _PASTE_CLOSE not in payload:
+        # With ENABLE_VIRTUAL_TERMINAL_INPUT, special keys arrive as VT
+        # escape sequences instead of \x00/\xe0 extended-key pairs — an
+        # arrow press (or a key-repeat flood of them) is a 3+ char all-
+        # text burst that would otherwise classify as a paste and land
+        # in the buffer as literal ESC garbage. Real terminal pastes are
+        # always bracketed while ?2004h is armed, so an ESC-bearing
+        # burst WITHOUT markers is typing: dispatch per key and let the
+        # editor's CSI state machine handle the sequences.
+        return None
+    return payload
 
 
 def _editor_paste_active() -> bool:
@@ -599,11 +610,35 @@ def _listen_windows(
     on_cancel_agent: Optional[Callable[[], None]] = None,
     suspend_event: Optional[threading.Event] = None,
     released_event: Optional[threading.Event] = None,
+) -> None:
+    """Windows listener entry — wraps the loop so VT input is ALWAYS
+    released on the way out (the parent shell expects classic key
+    events; see ``enable_windows_vt_input`` for the scope contract)."""
+    from code_puppy.terminal_utils import disable_windows_vt_input
+
+    try:
+        _listen_windows_loop(
+            stop_event, on_escape, on_cancel_agent, suspend_event, released_event
+        )
+    finally:
+        disable_windows_vt_input()
+
+
+def _listen_windows_loop(
+    stop_event: threading.Event,
+    on_escape: Callable[[], None],
+    on_cancel_agent: Optional[Callable[[], None]] = None,
+    suspend_event: Optional[threading.Event] = None,
+    released_event: Optional[threading.Event] = None,
 ) -> None:
     import msvcrt
     import time
 
-    from code_puppy.terminal_utils import ensure_ctrl_c_disabled
+    from code_puppy.terminal_utils import (
+        disable_windows_vt_input,
+        enable_windows_vt_input,
+        ensure_ctrl_c_disabled,
+    )
 
     cancel_agent_char = _resolve_cancel_char(on_cancel_agent)
 
@@ -612,12 +647,17 @@ def _listen_windows(
     next_clamp_check = 0.0  # first lap re-clamps immediately
 
     while not stop_event.is_set():
-        # Honor suspend: msvcrt doesn't reconfigure the terminal, so the
-        # contract here is purely "don't read keystrokes while suspended."
+        # Honor suspend. Whoever suspended us (prompt_toolkit TUIs, the
+        # ask_user picker) reads via ReadConsoleInput and expects classic
+        # key events — hand the console back without VT input, and
+        # re-clamp immediately (not up to 1s later) on resume so a paste
+        # right after a menu closes isn't dropped.
         if suspend_event is not None and suspend_event.is_set():
+            disable_windows_vt_input()
             _wait_while_suspended(stop_event, suspend_event, released_event)
             if stop_event.is_set():
                 return
+            next_clamp_check = 0.0
             continue
 
         # Self-healing console clamp. Anything sharing the console (shell
@@ -639,6 +679,16 @@ def _listen_windows(
                 ensure_ctrl_c_disabled()
             except Exception:
                 pass
+            # VT-input clamp, same self-healing cadence: without
+            # ENABLE_VIRTUAL_TERMINAL_INPUT, ConPTY silently drops the
+            # bracketed-paste markers Windows Terminal sends for an
+            # image-only Ctrl+V (an EMPTY paste has no key events to
+            # synthesize) — the Windows image-paste-goes-dead bug.
+            # No-op (one GetConsoleMode) when the flag is already set.
+            try:
+                enable_windows_vt_input()
+            except Exception:
+                pass
 
         try:
             if msvcrt.kbhit():

{code_puppy-0.0.612 → code_puppy-0.0.613}/code_puppy/terminal_utils.py

@@ -154,6 +154,87 @@ def ensure_windows_vt_processing() -> bool:
         return False  # can't confirm VT -> fail safe, degrade to classic
 
 
+#: ENABLE_VIRTUAL_TERMINAL_INPUT — stdin delivers VT sequences verbatim.
+_ENABLE_VIRTUAL_TERMINAL_INPUT = 0x0200
+
+
+def enable_windows_vt_input() -> bool:
+    """Enable VT input (``ENABLE_VIRTUAL_TERMINAL_INPUT``) on stdin, verified.
+
+    ConPTY only forwards terminal-side VT input sequences to a client
+    whose stdin carries this flag. Bracketed-paste markers
+    (``ESC[200~``/``ESC[201~``) have no key-event representation, so
+    without the flag ConPTY silently DROPS them — and Windows Terminal
+    pastes an image-only clipboard as an EMPTY bracketed paste, meaning
+    the app receives NOTHING and Ctrl+V image capture never fires.
+    (Text pastes still arrive as synthesized keystrokes, which is why
+    only image paste broke.) Verified live via console probe 2026-07-08:
+    mode ``0x1f7`` → 0 chars delivered; mode ``0x3f7`` → the 12-char
+    empty bracketed paste.
+
+    Scope contract: only the Windows key listener enables this, while it
+    owns stdin — and it disables it around suspensions, because
+    ``ReadConsoleInput``-based readers (prompt_toolkit TUIs) expect
+    classic key events. Returns True when the flag is CONFIRMED set via
+    a mode read-back (mirrors :func:`ensure_windows_vt_processing`;
+    ancient hosts silently no-op ``SetConsoleMode``). Never raises.
+    """
+    if platform.system() != "Windows":
+        return False
+
+    try:
+        import ctypes
+
+        kernel32 = ctypes.windll.kernel32
+        stdin_handle = kernel32.GetStdHandle(-10)  # STD_INPUT_HANDLE
+
+        mode = ctypes.c_ulong()
+        if not kernel32.GetConsoleMode(stdin_handle, ctypes.byref(mode)):
+            return False
+        if mode.value & _ENABLE_VIRTUAL_TERMINAL_INPUT:
+            return True  # already on
+
+        if not kernel32.SetConsoleMode(
+            stdin_handle, mode.value | _ENABLE_VIRTUAL_TERMINAL_INPUT
+        ):
+            return False
+
+        verify = ctypes.c_ulong()
+        if not kernel32.GetConsoleMode(stdin_handle, ctypes.byref(verify)):
+            return False
+        return bool(verify.value & _ENABLE_VIRTUAL_TERMINAL_INPUT)
+    except Exception:
+        return False
+
+
+def disable_windows_vt_input() -> None:
+    """Clear ``ENABLE_VIRTUAL_TERMINAL_INPUT`` from stdin (best-effort).
+
+    Called by the Windows key listener before parking for a suspension
+    and on exit, so ``ReadConsoleInput``-based readers (prompt_toolkit
+    TUIs, the parent shell after we quit) get classic key events instead
+    of raw VT sequences. Never raises.
+    """
+    if platform.system() != "Windows":
+        return
+
+    try:
+        import ctypes
+
+        kernel32 = ctypes.windll.kernel32
+        stdin_handle = kernel32.GetStdHandle(-10)  # STD_INPUT_HANDLE
+
+        mode = ctypes.c_ulong()
+        if not kernel32.GetConsoleMode(stdin_handle, ctypes.byref(mode)):
+            return
+        if mode.value & _ENABLE_VIRTUAL_TERMINAL_INPUT:
+            kernel32.SetConsoleMode(
+                stdin_handle, mode.value & ~_ENABLE_VIRTUAL_TERMINAL_INPUT
+            )
+    except Exception:
+        pass
+
+
 def flush_windows_keyboard_buffer() -> None:
     """Flush the Windows keyboard buffer.
 

{code_puppy-0.0.612 → code_puppy-0.0.613}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "code-puppy"
-version = "0.0.612"
+version = "0.0.613"
 description = "Code generation agent"
 readme = "README.md"
 requires-python = ">=3.11,<3.15"