code-puppy 0.0.338__py3-none-any.whl → 0.0.340__py3-none-any.whl

code_puppy/claude_cache_client.py

@@ -10,10 +10,13 @@ serialization, avoiding httpx/Pydantic internals.
 from __future__ import annotations
 
 import json
+import logging
 from typing import Any, Callable, MutableMapping
 
 import httpx
 
+logger = logging.getLogger(__name__)
+
 try:
     from anthropic import AsyncAnthropic
 except ImportError:  # pragma: no cover - optional dep
@@ -58,25 +61,44 @@ class ClaudeCacheAsyncClient(httpx.AsyncClient):
             pass
         response = await super().send(request, *args, **kwargs)
         try:
-            if response.status_code == 401 and not request.extensions.get(
+            # Check for both 401 and 400 - Anthropic/Cloudflare may return 400 for auth errors
+            # Also check if it's a Cloudflare HTML error response
+            if response.status_code in (400, 401) and not request.extensions.get(
                 "claude_oauth_refresh_attempted"
             ):
-                refreshed_token = self._refresh_claude_oauth_token()
-                if refreshed_token:
-                    await response.aclose()
-                    body_bytes = self._extract_body_bytes(request)
-                    headers = dict(request.headers)
-                    self._update_auth_headers(headers, refreshed_token)
-                    retry_request = self.build_request(
-                        method=request.method,
-                        url=request.url,
-                        headers=headers,
-                        content=body_bytes,
-                    )
-                    retry_request.extensions["claude_oauth_refresh_attempted"] = True
-                    return await super().send(retry_request, *args, **kwargs)
-        except Exception:
-            pass
+                # Determine if this is an auth error (including Cloudflare HTML errors)
+                is_auth_error = response.status_code == 401
+
+                if response.status_code == 400:
+                    # Check if this is a Cloudflare HTML error
+                    is_auth_error = self._is_cloudflare_html_error(response)
+                    if is_auth_error:
+                        logger.info(
+                            "Detected Cloudflare 400 error (likely auth-related), attempting token refresh"
+                        )
+
+                if is_auth_error:
+                    refreshed_token = self._refresh_claude_oauth_token()
+                    if refreshed_token:
+                        logger.info("Token refreshed successfully, retrying request")
+                        await response.aclose()
+                        body_bytes = self._extract_body_bytes(request)
+                        headers = dict(request.headers)
+                        self._update_auth_headers(headers, refreshed_token)
+                        retry_request = self.build_request(
+                            method=request.method,
+                            url=request.url,
+                            headers=headers,
+                            content=body_bytes,
+                        )
+                        retry_request.extensions["claude_oauth_refresh_attempted"] = (
+                            True
+                        )
+                        return await super().send(retry_request, *args, **kwargs)
+                    else:
+                        logger.warning("Token refresh failed, returning original error")
+        except Exception as exc:
+            logger.debug("Error during token refresh attempt: %s", exc)
         return response
 
     @staticmethod
@@ -111,15 +133,51 @@ class ClaudeCacheAsyncClient(httpx.AsyncClient):
         else:
             headers["Authorization"] = bearer_value
 
+    @staticmethod
+    def _is_cloudflare_html_error(response: httpx.Response) -> bool:
+        """Check if this is a Cloudflare HTML error response.
+
+        Cloudflare often returns HTML error pages with status 400 when
+        there are authentication issues.
+        """
+        # Check content type
+        content_type = response.headers.get("content-type", "")
+        if "text/html" not in content_type.lower():
+            return False
+
+        # Check if body contains Cloudflare markers
+        try:
+            # Read response body if not already consumed
+            if hasattr(response, "_content") and response._content:
+                body = response._content.decode("utf-8", errors="ignore")
+            else:
+                # Try to read the text (this might be already consumed)
+                try:
+                    body = response.text
+                except Exception:
+                    return False
+
+            # Look for Cloudflare and 400 Bad Request markers
+            body_lower = body.lower()
+            return "cloudflare" in body_lower and "400 bad request" in body_lower
+        except Exception as exc:
+            logger.debug("Error checking for Cloudflare error: %s", exc)
+            return False
+
     def _refresh_claude_oauth_token(self) -> str | None:
         try:
             from code_puppy.plugins.claude_code_oauth.utils import refresh_access_token
 
+            logger.info("Attempting to refresh Claude Code OAuth token...")
             refreshed_token = refresh_access_token(force=True)
             if refreshed_token:
                 self._update_auth_headers(self.headers, refreshed_token)
+                logger.info("Successfully refreshed Claude Code OAuth token")
+            else:
+                logger.warning("Token refresh returned None")
             return refreshed_token
-        except Exception:
+        except Exception as exc:
+            logger.error("Exception during token refresh: %s", exc)
             return None
 
     @staticmethod

code_puppy/cli_runner.py

@@ -22,6 +22,7 @@ from rich.console import Console
 from code_puppy import __version__, callbacks, plugins
 from code_puppy.agents import get_current_agent
 from code_puppy.command_line.attachments import parse_prompt_attachments
+from code_puppy.command_line.clipboard import get_clipboard_manager
 from code_puppy.config import (
     AUTOSAVE_DIR,
     COMMAND_HISTORY_FILE,
@@ -143,8 +144,8 @@ async def main():
         except ImportError:
             emit_system_message("🐶 Code Puppy is Loading...")
 
-        # Check for truecolor support and warn if not available
-        print_truecolor_warning(display_console)
+        # Truecolor warning moved to interactive_mode() so it prints LAST
+        # after all the help stuff - max visibility for the ugly red box!
 
     available_port = find_available_port()
     if available_port is None:
@@ -354,6 +355,13 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
     emit_system_message(
         "Type @ for path completion, or /model to pick a model. Toggle multiline with Alt+M or F2; newline: Ctrl+J."
     )
+    emit_system_message("Paste images: Ctrl+V (even on Mac!), F3, or /paste command.")
+    import platform
+
+    if platform.system() == "Darwin":
+        emit_system_message(
+            "💡 macOS tip: Use Ctrl+V (not Cmd+V) to paste images in terminal."
+        )
     cancel_key = get_cancel_agent_display_name()
     emit_system_message(
         f"Press {cancel_key} during processing to cancel the current task or inference. Use Ctrl+X to interrupt running shell commands."
@@ -374,6 +382,10 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
 
         emit_warning(f"MOTD error: {e}")
 
+    # Print truecolor warning LAST so it's the most visible thing on startup
+    # Big ugly red box should be impossible to miss! 🔴
+    print_truecolor_warning(display_console)
+
     # Initialize the runtime agent manager
     if initial_command:
         from code_puppy.agents import get_current_agent
@@ -567,6 +579,7 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
 
         # Check for clear command (supports both `clear` and `/clear`)
         if task.strip().lower() in ("clear", "/clear"):
+            from code_puppy.command_line.clipboard import get_clipboard_manager
             from code_puppy.messaging import (
                 emit_info,
                 emit_system_message,
@@ -579,6 +592,13 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
             emit_warning("Conversation history cleared!")
             emit_system_message("The agent will not remember previous interactions.")
             emit_info(f"Auto-save session rotated to: {new_session_id}")
+
+            # Also clear pending clipboard images
+            clipboard_manager = get_clipboard_manager()
+            clipboard_count = clipboard_manager.get_pending_count()
+            clipboard_manager.clear_pending()
+            if clipboard_count > 0:
+                emit_info(f"Cleared {clipboard_count} pending clipboard image(s)")
             continue
 
         # Parse attachments first so leading paths aren't misread as commands
@@ -761,6 +781,7 @@ async def run_prompt_with_attachments(
         tuple: (result, task) where result is the agent response and task is the asyncio task
     """
     import asyncio
+    import re
 
     from code_puppy.messaging import emit_system_message, emit_warning
 
@@ -769,21 +790,41 @@ async def run_prompt_with_attachments(
     for warning in processed_prompt.warnings:
         emit_warning(warning)
 
+    # Get clipboard images and merge with file attachments
+    clipboard_manager = get_clipboard_manager()
+    clipboard_images = clipboard_manager.get_pending_images()
+
+    # Clear pending clipboard images after retrieval
+    clipboard_manager.clear_pending()
+
+    # Build summary of all attachments
     summary_parts = []
     if processed_prompt.attachments:
-        summary_parts.append(f"binary files: {len(processed_prompt.attachments)}")
+        summary_parts.append(f"files: {len(processed_prompt.attachments)}")
+    if clipboard_images:
+        summary_parts.append(f"clipboard images: {len(clipboard_images)}")
     if processed_prompt.link_attachments:
         summary_parts.append(f"urls: {len(processed_prompt.link_attachments)}")
     if summary_parts:
         emit_system_message("Attachments detected -> " + ", ".join(summary_parts))
 
-    if not processed_prompt.prompt:
+    # Clean up clipboard placeholders from the prompt text
+    cleaned_prompt = processed_prompt.prompt
+    if clipboard_images and cleaned_prompt:
+        cleaned_prompt = re.sub(
+            r"\[📋 clipboard image \d+\]\s*", "", cleaned_prompt
+        ).strip()
+
+    if not cleaned_prompt:
         emit_warning(
             "Prompt is empty after removing attachments; add instructions and retry."
         )
         return None, None
 
+    # Combine file attachments with clipboard images
     attachments = [attachment.content for attachment in processed_prompt.attachments]
+    attachments.extend(clipboard_images)  # Add clipboard images
+
     link_attachments = [link.url_part for link in processed_prompt.link_attachments]
 
     # IMPORTANT: Set the shared console on the agent so that streaming output
@@ -795,7 +836,7 @@ async def run_prompt_with_attachments(
     # Create the agent task first so we can track and cancel it
     agent_task = asyncio.create_task(
         agent.run_with_mcp(
-            processed_prompt.prompt,
+            cleaned_prompt,  # Use cleaned prompt (clipboard placeholders removed)
             attachments=attachments,
             link_attachments=link_attachments,
         )

code_puppy/command_line/clipboard.py

@@ -0,0 +1,527 @@
+"""Clipboard image reading and management utilities.
+
+Provides cross-platform clipboard image capture:
+- Windows/macOS: Uses PIL.ImageGrab (native)
+- Linux: Falls back to xclip or wl-paste via subprocess
+
+Also provides a thread-safe ClipboardAttachmentManager for managing
+pending clipboard image attachments in the CLI.
+"""
+
+import io
+import logging
+import subprocess
+import sys
+import threading
+import time
+from typing import Optional
+
+# Try to import PIL - it's optional but needed for clipboard image support
+try:
+    from PIL import Image, ImageGrab
+
+    PIL_AVAILABLE = True
+    # SEC-CLIP-002: Protect against decompression bombs
+    # Set explicit limit (PIL default) to prevent memory exhaustion from malicious images
+    Image.MAX_IMAGE_PIXELS = 178956970
+except ImportError:
+    PIL_AVAILABLE = False
+    Image = None  # type: ignore[misc, assignment]
+    ImageGrab = None  # type: ignore[misc, assignment]
+
+# Import BinaryContent for pydantic-ai integration
+try:
+    from pydantic_ai import BinaryContent
+
+    BINARY_CONTENT_AVAILABLE = True
+except ImportError:
+    BINARY_CONTENT_AVAILABLE = False
+    BinaryContent = None  # type: ignore[misc, assignment]
+
+logger = logging.getLogger(__name__)
+
+# Constants
+MAX_IMAGE_SIZE_BYTES = 10 * 1024 * 1024  # 10MB
+MAX_IMAGE_DIMENSION = 4096  # Max width/height for resize
+MAX_PENDING_IMAGES = (
+    10  # SEC-CLIP-001: Limit pending images to prevent memory exhaustion
+)
+CLIPBOARD_RATE_LIMIT_SECONDS: float = 0.5  # SEC-CLIP-004: Max 2 captures per second
+
+# Rate limiting state
+_last_clipboard_capture: float = 0.0
+
+
+def _safe_open_image(image_bytes: bytes) -> Optional["Image.Image"]:
+    """Safely open and verify an image from bytes.
+
+    Verifies image integrity to protect against malicious images.
+
+    Args:
+        image_bytes: Raw image bytes to open.
+
+    Returns:
+        PIL Image if valid, None if verification fails.
+    """
+    if not PIL_AVAILABLE or Image is None:
+        return None
+
+    try:
+        # First pass: verify integrity without fully loading
+        verify_image = Image.open(io.BytesIO(image_bytes))
+        verify_image.verify()  # Checks for corruption/malicious data
+
+        # Re-open after verify (verify() closes the image)
+        image = Image.open(io.BytesIO(image_bytes))
+        return image
+    except Image.DecompressionBombError as e:
+        logger.warning(f"Rejected decompression bomb image: {e}")
+        return None
+    except Image.UnidentifiedImageError as e:
+        logger.warning(f"Rejected unidentified image format: {e}")
+        return None
+    except OSError as e:
+        logger.warning(f"Rejected potentially malicious image: {e}")
+        return None
+    except Exception as e:
+        logger.warning(f"Failed to open/verify image: {type(e).__name__}: {e}")
+        return None
+
+
+def _check_linux_clipboard_tool() -> Optional[str]:
+    """Check which Linux clipboard tool is available.
+
+    Returns:
+        'xclip', 'wl-paste', or None if neither is available.
+    """
+    # Check for wl-paste first (Wayland)
+    try:
+        subprocess.run(
+            ["wl-paste", "--version"],
+            capture_output=True,
+            timeout=5,
+        )
+        return "wl-paste"
+    except (FileNotFoundError, subprocess.TimeoutExpired):
+        pass
+
+    # Check for xclip (X11)
+    try:
+        subprocess.run(
+            ["xclip", "-version"],
+            capture_output=True,
+            timeout=5,
+        )
+        return "xclip"
+    except (FileNotFoundError, subprocess.TimeoutExpired):
+        pass
+
+    return None
+
+
+def _get_linux_clipboard_image() -> Optional[bytes]:
+    """Get clipboard image on Linux using xclip or wl-paste.
+
+    Returns:
+        PNG bytes if image found, None otherwise.
+    """
+    tool = _check_linux_clipboard_tool()
+
+    if tool is None:
+        logger.warning(
+            "No clipboard tool found on Linux. "
+            "Install 'xclip' (X11) or 'wl-clipboard' (Wayland) for clipboard image support."
+        )
+        return None
+
+    try:
+        if tool == "wl-paste":
+            # wl-paste for Wayland
+            result = subprocess.run(
+                ["wl-paste", "--type", "image/png"],
+                capture_output=True,
+                timeout=10,
+            )
+            if result.returncode == 0 and result.stdout:
+                return result.stdout
+        elif tool == "xclip":
+            # xclip for X11
+            result = subprocess.run(
+                ["xclip", "-selection", "clipboard", "-t", "image/png", "-o"],
+                capture_output=True,
+                timeout=10,
+            )
+            if result.returncode == 0 and result.stdout:
+                return result.stdout
+    except subprocess.TimeoutExpired:
+        logger.warning(f"Timeout reading clipboard with {tool}")
+    except Exception as e:
+        logger.warning(f"Error reading clipboard with {tool}: {e}")
+
+    return None
+
+
+def _resize_image_if_needed(image: "Image.Image", max_bytes: int) -> "Image.Image":
+    """Resize image if it exceeds max size when saved as PNG.
+
+    Args:
+        image: PIL Image to potentially resize.
+        max_bytes: Maximum allowed size in bytes.
+
+    Returns:
+        Original or resized image.
+    """
+    if Image is None:
+        return image
+
+    # Check current size
+    buffer = io.BytesIO()
+    image.save(buffer, format="PNG", optimize=True)
+    current_size = buffer.tell()
+
+    if current_size <= max_bytes:
+        return image
+
+    logger.info(
+        f"Image size ({current_size / 1024 / 1024:.2f}MB) exceeds limit "
+        f"({max_bytes / 1024 / 1024:.2f}MB), resizing..."
+    )
+
+    # Calculate scale factor to reduce size
+    # Rough estimate: size scales with area (width * height)
+    scale_factor = (max_bytes / current_size) ** 0.5 * 0.9  # 0.9 for safety margin
+
+    new_width = int(image.width * scale_factor)
+    new_height = int(image.height * scale_factor)
+
+    # Ensure we don't go below minimum dimensions
+    new_width = max(new_width, 100)
+    new_height = max(new_height, 100)
+
+    # Also cap at max dimension
+    if new_width > MAX_IMAGE_DIMENSION:
+        ratio = MAX_IMAGE_DIMENSION / new_width
+        new_width = MAX_IMAGE_DIMENSION
+        new_height = int(new_height * ratio)
+    if new_height > MAX_IMAGE_DIMENSION:
+        ratio = MAX_IMAGE_DIMENSION / new_height
+        new_height = MAX_IMAGE_DIMENSION
+        new_width = int(new_width * ratio)
+
+    resized = image.resize((new_width, new_height), Image.Resampling.LANCZOS)
+    logger.info(
+        f"Resized image from {image.width}x{image.height} to {new_width}x{new_height}"
+    )
+
+    return resized
+
+
+def has_image_in_clipboard() -> bool:
+    """Check if clipboard contains an image.
+
+    Returns:
+        True if clipboard contains an image, False otherwise.
+    """
+    if sys.platform == "linux":
+        # For Linux, we need to actually try to get the image
+        # since there's no lightweight "check" method
+        tool = _check_linux_clipboard_tool()
+        if tool is None:
+            return False
+
+        try:
+            if tool == "wl-paste":
+                result = subprocess.run(
+                    ["wl-paste", "--list-types"],
+                    capture_output=True,
+                    timeout=5,
+                    text=True,
+                )
+                return "image/png" in result.stdout or "image/" in result.stdout
+            elif tool == "xclip":
+                result = subprocess.run(
+                    ["xclip", "-selection", "clipboard", "-t", "TARGETS", "-o"],
+                    capture_output=True,
+                    timeout=5,
+                    text=True,
+                )
+                return "image/png" in result.stdout or "image/" in result.stdout
+        except (subprocess.TimeoutExpired, Exception):
+            return False
+
+        return False
+
+    # Windows/macOS - use PIL
+    if not PIL_AVAILABLE:
+        return False
+
+    try:
+        image = ImageGrab.grabclipboard()
+        return image is not None and isinstance(image, Image.Image)
+    except Exception as e:
+        logger.debug(f"Error checking clipboard: {e}")
+        return False
+
+
+def get_clipboard_image() -> Optional[bytes]:
+    """Get clipboard image as PNG bytes.
+
+    Handles cross-platform clipboard access:
+    - Windows/macOS: Uses PIL.ImageGrab
+    - Linux: Uses xclip or wl-paste
+
+    Images larger than 10MB are automatically resized.
+
+    Returns:
+        PNG bytes if clipboard contains an image, None otherwise.
+    """
+    image_bytes: Optional[bytes] = None
+
+    # Linux path - use command line tools
+    if sys.platform == "linux":
+        image_bytes = _get_linux_clipboard_image()
+        if image_bytes is None:
+            return None
+
+        # Check size and resize if needed
+        if len(image_bytes) > MAX_IMAGE_SIZE_BYTES:
+            if not PIL_AVAILABLE:
+                logger.warning(
+                    f"Image size ({len(image_bytes) / 1024 / 1024:.2f}MB) exceeds limit, "
+                    "but PIL not available for resizing."
+                )
+                return None
+
+            try:
+                # Use safe image opening with verification
+                image = _safe_open_image(image_bytes)
+                if image is None:
+                    logger.warning(
+                        "Image verification failed for Linux clipboard image"
+                    )
+                    return None
+                image = _resize_image_if_needed(image, MAX_IMAGE_SIZE_BYTES)
+                buffer = io.BytesIO()
+                image.save(buffer, format="PNG", optimize=True)
+                image_bytes = buffer.getvalue()
+            except Exception as e:
+                logger.warning(f"Error resizing Linux clipboard image: {e}")
+                return None
+        else:
+            # Verify even small images for safety
+            if PIL_AVAILABLE:
+                image = _safe_open_image(image_bytes)
+                if image is None:
+                    logger.warning(
+                        "Image verification failed for Linux clipboard image"
+                    )
+                    return None
+
+        return image_bytes
+
+    # Windows/macOS path - use PIL
+    if not PIL_AVAILABLE:
+        logger.warning("PIL/Pillow not available. Install with: pip install Pillow")
+        return None
+
+    try:
+        image = ImageGrab.grabclipboard()
+
+        if image is None:
+            return None
+
+        if not isinstance(image, Image.Image):
+            # Could be a list of file paths on some systems
+            logger.debug(f"Clipboard contains non-image data: {type(image)}")
+            return None
+
+        # Log original dimensions
+        logger.info(f"Captured clipboard image: {image.width}x{image.height}")
+
+        # Convert to RGB if necessary (handles RGBA, P mode, etc.)
+        if image.mode in ("RGBA", "LA") or (
+            image.mode == "P" and "transparency" in image.info
+        ):
+            # Keep alpha channel for PNG
+            pass
+        elif image.mode != "RGB":
+            image = image.convert("RGB")
+
+        # Resize if needed
+        image = _resize_image_if_needed(image, MAX_IMAGE_SIZE_BYTES)
+
+        # Convert to PNG bytes
+        buffer = io.BytesIO()
+        image.save(buffer, format="PNG", optimize=True)
+        image_bytes = buffer.getvalue()
+
+        logger.info(f"Clipboard image size: {len(image_bytes) / 1024:.1f}KB")
+        return image_bytes
+
+    except Exception as e:
+        logger.warning(f"Error reading clipboard image: {e}")
+        return None
+
+
+def get_clipboard_image_as_binary_content() -> Optional["BinaryContent"]:
+    """Get clipboard image as pydantic-ai BinaryContent.
+
+    This is the preferred method for integrating clipboard images
+    with pydantic-ai agents.
+
+    Returns:
+        BinaryContent with PNG image if available, None otherwise.
+    """
+    if not BINARY_CONTENT_AVAILABLE:
+        logger.warning("pydantic-ai BinaryContent not available")
+        return None
+
+    image_bytes = get_clipboard_image()
+    if image_bytes is None:
+        return None
+
+    return BinaryContent(data=image_bytes, media_type="image/png")
+
+
+class ClipboardAttachmentManager:
+    """Thread-safe manager for pending clipboard image attachments.
+
+    This class manages clipboard images that have been captured but not yet
+    sent to the AI model. It provides a simple interface for adding images,
+    retrieving them as BinaryContent, and clearing the queue.
+
+    Usage:
+        manager = get_clipboard_manager()
+        placeholder = manager.add_image(image_bytes)
+        # Later, when sending to AI:
+        images = manager.get_pending_images()
+        manager.clear_pending()
+    """
+
+    def __init__(self) -> None:
+        """Initialize the clipboard attachment manager."""
+        self._pending_images: list[bytes] = []
+        self._lock = threading.Lock()
+        self._counter = 0
+
+    def add_image(self, image_bytes: bytes) -> str:
+        """Add image bytes to pending attachments.
+
+        Args:
+            image_bytes: PNG image bytes to add.
+
+        Returns:
+            Placeholder ID string like '[📋 clipboard image 1]'
+
+        Raises:
+            ValueError: If MAX_PENDING_IMAGES limit is reached.
+        """
+        with self._lock:
+            # SEC-CLIP-001: Check limit BEFORE adding to prevent memory exhaustion
+            if len(self._pending_images) >= MAX_PENDING_IMAGES:
+                raise ValueError(
+                    f"Maximum of {MAX_PENDING_IMAGES} pending images reached. "
+                    "Send your message to clear the queue, or use /paste clear."
+                )
+            self._counter += 1
+            self._pending_images.append(image_bytes)
+            placeholder = f"[📋 clipboard image {self._counter}]"
+            logger.debug(
+                f"Added clipboard image {self._counter} "
+                f"({len(image_bytes) / 1024:.1f}KB)"
+            )
+            return placeholder
+
+    def get_pending_images(self) -> list["BinaryContent"]:
+        """Get all pending images as BinaryContent list.
+
+        Returns:
+            List of BinaryContent objects for each pending image.
+            Returns empty list if BinaryContent not available.
+        """
+        if not BINARY_CONTENT_AVAILABLE:
+            logger.warning("BinaryContent not available, returning empty list")
+            return []
+
+        with self._lock:
+            return [
+                BinaryContent(data=img_bytes, media_type="image/png")
+                for img_bytes in self._pending_images
+            ]
+
+    def clear_pending(self) -> None:
+        """Clear all pending images."""
+        with self._lock:
+            count = len(self._pending_images)
+            self._pending_images.clear()
+            if count > 0:
+                logger.debug(f"Cleared {count} pending clipboard image(s)")
+
+    def get_pending_count(self) -> int:
+        """Get count of pending images.
+
+        Returns:
+            Number of images currently pending.
+        """
+        with self._lock:
+            return len(self._pending_images)
+
+    def has_pending(self) -> bool:
+        """Check if there are any pending images.
+
+        Returns:
+            True if there are pending images, False otherwise.
+        """
+        with self._lock:
+            return len(self._pending_images) > 0
+
+
+# Global singleton instance
+_clipboard_manager: Optional[ClipboardAttachmentManager] = None
+_manager_lock = threading.Lock()
+
+
+def get_clipboard_manager() -> ClipboardAttachmentManager:
+    """Get or create the global clipboard manager singleton.
+
+    Returns:
+        The global ClipboardAttachmentManager instance.
+    """
+    global _clipboard_manager
+
+    if _clipboard_manager is None:
+        with _manager_lock:
+            # Double-check locking pattern
+            if _clipboard_manager is None:
+                _clipboard_manager = ClipboardAttachmentManager()
+
+    return _clipboard_manager
+
+
+def capture_clipboard_image_to_pending() -> Optional[str]:
+    """Convenience function to capture clipboard image and add to pending.
+
+    This combines get_clipboard_image() and add_image() into a single call.
+    Includes rate limiting to prevent rapid captures (SEC-CLIP-004).
+
+    Returns:
+        Placeholder string if image captured, None if no image or rate limited.
+    """
+    global _last_clipboard_capture
+
+    # SEC-CLIP-004: Rate limiting to prevent rapid captures
+    now = time.monotonic()
+    if now - _last_clipboard_capture < CLIPBOARD_RATE_LIMIT_SECONDS:
+        logger.debug("Clipboard capture rate limited")
+        return None  # Rate limited, silently ignore
+
+    image_bytes = get_clipboard_image()
+    if image_bytes is None:
+        return None
+
+    manager = get_clipboard_manager()
+    placeholder = manager.add_image(image_bytes)
+
+    # Update timestamp on successful capture
+    _last_clipboard_capture = now
+    return placeholder

code_puppy/command_line/core_commands.py

@@ -115,6 +115,40 @@ def handle_motd_command(command: str) -> bool:
     return True
 
 
+@register_command(
+    name="paste",
+    description="Paste image from clipboard (same as F3, or Ctrl+V with image)",
+    usage="/paste, /clipboard, /cb",
+    aliases=["clipboard", "cb"],
+    category="core",
+)
+def handle_paste_command(command: str) -> bool:
+    """Paste an image from the clipboard into the pending attachments."""
+    from code_puppy.command_line.clipboard import (
+        capture_clipboard_image_to_pending,
+        get_clipboard_manager,
+        has_image_in_clipboard,
+    )
+    from code_puppy.messaging import emit_info, emit_success, emit_warning
+
+    if not has_image_in_clipboard():
+        emit_warning("No image found in clipboard")
+        emit_info("Copy an image (screenshot, from browser, etc.) and try again")
+        return True
+
+    placeholder = capture_clipboard_image_to_pending()
+    if placeholder:
+        manager = get_clipboard_manager()
+        count = manager.get_pending_count()
+        emit_success(f"📋 {placeholder}")
+        emit_info(f"Total pending clipboard images: {count}")
+        emit_info("Type your prompt and press Enter to send with the image(s)")
+    else:
+        emit_warning("Failed to capture clipboard image")
+
+    return True
+
+
 @register_command(
     name="tutorial",
     description="Run the interactive tutorial wizard",

code_puppy/command_line/prompt_toolkit_completion.py

@@ -27,6 +27,11 @@ from code_puppy.command_line.attachments import (
     _detect_path_tokens,
     _tokenise,
 )
+from code_puppy.command_line.clipboard import (
+    capture_clipboard_image_to_pending,
+    get_clipboard_manager,
+    has_image_in_clipboard,
+)
 from code_puppy.command_line.command_registry import get_unique_commands
 from code_puppy.command_line.file_path_completion import FilePathCompleter
 from code_puppy.command_line.load_context_completion import LoadContextCompleter
@@ -644,6 +649,113 @@ async def get_input_with_combined_completion(
         else:
             event.current_buffer.validate_and_handle()
 
+    # Handle bracketed paste (triggered by most terminal Cmd+V / Ctrl+V)
+    # This is the PRIMARY paste handler - works with Cmd+V on macOS terminals
+    @bindings.add(Keys.BracketedPaste)
+    def handle_bracketed_paste(event):
+        """Handle bracketed paste - works with Cmd+V on macOS terminals."""
+        # The pasted data is in event.data
+        pasted_data = event.data
+
+        # Check if clipboard has an image (the pasted text might just be empty or a file path)
+        try:
+            if has_image_in_clipboard():
+                placeholder = capture_clipboard_image_to_pending()
+                if placeholder:
+                    event.app.current_buffer.insert_text(placeholder + " ")
+                    count = get_clipboard_manager().get_pending_count()
+                    sys.stdout.write(f"\033[36m📋 +image ({count})\033[0m ")
+                    sys.stdout.flush()
+                    return  # Don't also paste the text data
+        except Exception:
+            pass
+
+        # No image - insert the pasted text as normal
+        if pasted_data:
+            event.app.current_buffer.insert_text(pasted_data)
+
+    # Fallback Ctrl+V for terminals without bracketed paste support
+    @bindings.add("c-v", eager=True)
+    def handle_smart_paste(event):
+        """Handle Ctrl+V - auto-detect image vs text in clipboard."""
+        try:
+            # Check for image first
+            if has_image_in_clipboard():
+                placeholder = capture_clipboard_image_to_pending()
+                if placeholder:
+                    event.app.current_buffer.insert_text(placeholder + " ")
+                    count = get_clipboard_manager().get_pending_count()
+                    sys.stdout.write(f"\033[36m📋 +image ({count})\033[0m ")
+                    sys.stdout.flush()
+                    return  # Don't also paste text
+        except Exception:
+            pass  # Fall through to text paste on any error
+
+        # No image (or error) - do normal text paste
+        # prompt_toolkit doesn't have built-in paste, so we handle it manually
+        try:
+            import platform
+            import subprocess
+
+            text = None
+            system = platform.system()
+
+            if system == "Darwin":  # macOS
+                result = subprocess.run(
+                    ["pbpaste"], capture_output=True, text=True, timeout=2
+                )
+                if result.returncode == 0:
+                    text = result.stdout
+            elif system == "Windows":
+                # Windows - use powershell
+                result = subprocess.run(
+                    ["powershell", "-command", "Get-Clipboard"],
+                    capture_output=True,
+                    text=True,
+                    timeout=2,
+                )
+                if result.returncode == 0:
+                    text = result.stdout.rstrip("\r\n")
+            else:  # Linux
+                # Try xclip first, then xsel
+                for cmd in [
+                    ["xclip", "-selection", "clipboard", "-o"],
+                    ["xsel", "--clipboard", "--output"],
+                ]:
+                    try:
+                        result = subprocess.run(
+                            cmd, capture_output=True, text=True, timeout=2
+                        )
+                        if result.returncode == 0:
+                            text = result.stdout
+                            break
+                    except FileNotFoundError:
+                        continue
+
+            if text:
+                event.app.current_buffer.insert_text(text)
+        except Exception:
+            pass  # Silently fail if text paste doesn't work
+
+    # F3 - dedicated image paste (shows error if no image)
+    @bindings.add("f3")
+    def handle_image_paste_f3(event):
+        """Handle F3 - paste image from clipboard (image-only, shows error if none)."""
+        try:
+            if has_image_in_clipboard():
+                placeholder = capture_clipboard_image_to_pending()
+                if placeholder:
+                    event.app.current_buffer.insert_text(placeholder + " ")
+                    count = get_clipboard_manager().get_pending_count()
+                    sys.stdout.write(f"\033[36m📋 +image ({count})\033[0m ")
+                    sys.stdout.flush()
+            else:
+                sys.stdout.write("\033[33m⚠️ no image\033[0m ")
+                sys.stdout.flush()
+        except Exception:
+            sys.stdout.write("\033[31m❌ clipboard error\033[0m ")
+            sys.stdout.flush()
+
     session = PromptSession(
         completer=completer,
         history=history,

code_puppy/mcp_/managed_server.py

@@ -222,18 +222,14 @@ class ManagedMCPServer:
                     http_kwargs["timeout"] = config["timeout"]
                 if "read_timeout" in config:
                     http_kwargs["read_timeout"] = config["read_timeout"]
-                if "headers" in config:
-                    # Expand environment variables in headers
-                    headers = config.get("headers")
-                    resolved_headers = {}
-                    if isinstance(headers, dict):
-                        for k, v in headers.items():
-                            if isinstance(v, str):
-                                resolved_headers[k] = os.path.expandvars(v)
-                            else:
-                                resolved_headers[k] = v
-                    http_kwargs["headers"] = resolved_headers
+
+                # Handle http_client vs headers (mutually exclusive)
+                if "http_client" in config:
+                    # Use provided http_client
+                    http_kwargs["http_client"] = config["http_client"]
+                elif config.get("headers"):
                     # Create HTTP client if headers are provided but no client specified
+                    http_kwargs["http_client"] = self._get_http_client()
 
                 self._pydantic_server = MCPServerStreamableHTTP(
                     **http_kwargs, process_tool_call=process_tool_call

code_puppy/tools/common.py

@@ -727,15 +727,9 @@ def _format_diff_with_syntax_highlighting(
                 result.append("\n")
             continue
 
-        # Handle diff headers specially
-        if line.startswith("---"):
-            result.append(line, style="yellow")
-        elif line.startswith("+++"):
-            result.append(line, style="yellow")
-        elif line.startswith("@@"):
-            result.append(line, style="cyan")
-        elif line.startswith(("diff ", "index ")):
-            result.append(line, style="dim")
+        # Skip diff headers - they're redundant noise since we show the filename in the banner
+        if line.startswith(("---", "+++", "@@", "diff ", "index ")):
+            continue
         else:
             # Determine line type and extract code content
             if line.startswith("-"):

{code_puppy-0.0.338.dist-info → code_puppy-0.0.340.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-puppy
-Version: 0.0.338
+Version: 0.0.340
 Summary: Code generation agent
 Project-URL: repository, https://github.com/mpfaffenberger/code_puppy
 Project-URL: HomePage, https://github.com/mpfaffenberger/code_puppy
@@ -22,6 +22,7 @@ Requires-Dist: httpx[http2]>=0.24.1
 Requires-Dist: json-repair>=0.46.2
 Requires-Dist: logfire>=0.7.1
 Requires-Dist: openai>=1.99.1
+Requires-Dist: pillow>=10.0.0
 Requires-Dist: playwright>=1.40.0
 Requires-Dist: prompt-toolkit>=3.0.52
 Requires-Dist: pydantic-ai==1.25.0

{code_puppy-0.0.338.dist-info → code_puppy-0.0.340.dist-info}/RECORD

@@ -2,8 +2,8 @@ code_puppy/__init__.py,sha256=xMPewo9RNHb3yfFNIk5WCbv2cvSPtJOCgK2-GqLbNnU,373
 code_puppy/__main__.py,sha256=pDVssJOWP8A83iFkxMLY9YteHYat0EyWDQqMkKHpWp4,203
 code_puppy/callbacks.py,sha256=hqTV--dNxG5vwWWm3MrEjmb8MZuHFFdmHePl23NXPHk,8621
 code_puppy/chatgpt_codex_client.py,sha256=Om0ANB_kpHubhCwNzF9ENf8RvKBqs0IYzBLl_SNw0Vk,9833
-code_puppy/claude_cache_client.py,sha256=QaucFONE0InS1GANCZwMFx-7sEptbZfjVzb_CgjvuUo,7949
-code_puppy/cli_runner.py,sha256=E7C2pCWof4JgNcCRgMlodeTs2DyWh0NaB7_a_nwafM0,33117
+code_puppy/claude_cache_client.py,sha256=hfDsb2x_L2maXqI0xQNX7gCDeHRI9XEttK0geoiNqQM,10678
+code_puppy/cli_runner.py,sha256=BQu5Sa9y_ueqtgvbmuhWS-Tmd1FAjMbhTrtjFKbVZjM,34919
 code_puppy/config.py,sha256=RlnrLkyFXm7h2Htf8rQA7vqoAyzLPMrESle417uLmFw,52373
 code_puppy/error_logging.py,sha256=a80OILCUtJhexI6a9GM-r5LqIdjvSRzggfgPp2jv1X0,3297
 code_puppy/gemini_code_assist.py,sha256=KGS7sO5OLc83nDF3xxS-QiU6vxW9vcm6hmzilu79Ef8,13867
@@ -47,11 +47,12 @@ code_puppy/command_line/__init__.py,sha256=y7WeRemfYppk8KVbCGeAIiTuiOszIURCDjOMZ
 code_puppy/command_line/add_model_menu.py,sha256=caXxSQc6dgx0qQ68RRFrDTsiH-wZjl4nUv2r0javhaM,43262
 code_puppy/command_line/attachments.py,sha256=4Q5I2Es4j0ltnz5wjw2z0QXMsiMJvEfWRkPf_lJeITM,13093
 code_puppy/command_line/autosave_menu.py,sha256=vW-2UqX8qT2Rb07ZSbsCG1MMwCPIH4MQ4YM9PEkcPyo,20105
+code_puppy/command_line/clipboard.py,sha256=oe9bfAX5RnT81FiYrDmhvHaePS1tAT-NFG1fSXubSD4,16869
 code_puppy/command_line/colors_menu.py,sha256=LoFVfJ-Mo-Eq9hnb2Rj5mn7oBCnadAGr-8NNHsHlu18,17273
 code_puppy/command_line/command_handler.py,sha256=CY9F27eovZJK_kpU1YmbroYLWGTCuouCOQ-TXfDp-nw,10916
 code_puppy/command_line/command_registry.py,sha256=qFySsw1g8dol3kgi0p6cXrIDlP11_OhOoaQ5nAadWXg,4416
 code_puppy/command_line/config_commands.py,sha256=qS9Cm758DPz2QGvHLhAV4Tp_Xfgo3PyoCoLDusbnmCw,25742
-code_puppy/command_line/core_commands.py,sha256=MhnyqcTIMheT8W1cqmfZTGLWo8iGM-fAAo8E3dNORro,26468
+code_puppy/command_line/core_commands.py,sha256=ujAPD4yDbXwYGJJfR2u4ei24eBV-Ps_-BVBjFMEoJy0,27668
 code_puppy/command_line/diff_menu.py,sha256=_Gr9SP9fbItk-08dya9WTAR53s_PlyAvEnbt-8VWKPk,24141
 code_puppy/command_line/file_path_completion.py,sha256=gw8NpIxa6GOpczUJRyh7VNZwoXKKn-yvCqit7h2y6Gg,2931
 code_puppy/command_line/load_context_completion.py,sha256=a3JvLDeLLSYxVgTjAdqWzS4spjv6ccCrK2LKZgVJ1IM,2202
@@ -62,7 +63,7 @@ code_puppy/command_line/motd.py,sha256=XuIk3UTLawwVFM-NfoaJGU5F2hPLASTFXq84UdDMT
 code_puppy/command_line/onboarding_slides.py,sha256=tHob7rB_n32dfjtPH-RSG0WLMjDHhlmNxfsF7WCgcVc,7191
 code_puppy/command_line/onboarding_wizard.py,sha256=U5lV_1P3IwDYZUHar0zKgdp121zzkvOwwORvdCZwFcw,10241
 code_puppy/command_line/pin_command_completion.py,sha256=juSvdqRpk7AdfkPy1DJx5NzfEUU5KYGlChvP0hisM18,11667
-code_puppy/command_line/prompt_toolkit_completion.py,sha256=x4Of32g8oH9ckhx-P6BigV7HUUhhjL8xkvK03uq9HRw,27308
+code_puppy/command_line/prompt_toolkit_completion.py,sha256=pyawy4qWGIkEMZVWDRYy_noFTD25k6vR3Z2fSH12jVU,32009
 code_puppy/command_line/session_commands.py,sha256=Jh8GGfhlfBAEVfucKLbcZjNaXYd0twImiOwq2ZnGdQQ,9902
 code_puppy/command_line/utils.py,sha256=7eyxDHjPjPB9wGDJQQcXV_zOsGdYsFgI0SGCetVmTqE,1251
 code_puppy/command_line/mcp/__init__.py,sha256=0-OQuwjq_pLiTVJ1_NrirVwdRerghyKs_MTZkwPC7YY,315
@@ -98,7 +99,7 @@ code_puppy/mcp_/config_wizard.py,sha256=JNNpgnSD6PFSyS3pTdEdD164oXd2VKp4VHLSz3To
 code_puppy/mcp_/dashboard.py,sha256=VtaFxLtPnbM_HL2TXRDAg6IqcM-EcFkoghGgkfhMrKI,9417
 code_puppy/mcp_/error_isolation.py,sha256=mpPBiH17zTXPsOEAn9WmkbwQwnt4gmgiaWv87JBJbUo,12426
 code_puppy/mcp_/health_monitor.py,sha256=n5R6EeYOYbUucUFe74qGWCU3g6Mep5UEQbLF0wbT0dU,19688
-code_puppy/mcp_/managed_server.py,sha256=KmrFQAQBS-XHuvkuWUltFJk2jiR0pt55gdQlI0gA2QE,14304
+code_puppy/mcp_/managed_server.py,sha256=APqFKjHtsG8iM4so1dYxvKnb0BTmppHnaY8UJ5DBE9g,14075
 code_puppy/mcp_/manager.py,sha256=pJ4cALicTxfwG2JIjJraLLf0Mzes-cEVAKIcUwfOoKA,29172
 code_puppy/mcp_/mcp_logs.py,sha256=o4pSHwELWIjEjqhfaMMEGrBvb159-VIgUp21E707BPo,6264
 code_puppy/mcp_/registry.py,sha256=U_t12WQ-En-KGyZoiTYdqlhp9NkDTWafu8g5InvF2NM,15774
@@ -160,7 +161,7 @@ code_puppy/prompts/codex_system_prompt.md,sha256=hEFTCziroLqZmqNle5kG34A8kvTteOW
 code_puppy/tools/__init__.py,sha256=BVTZ85jLHgDANwOnUSOz3UDlp8VQDq4DoGF23BRlyWw,6032
 code_puppy/tools/agent_tools.py,sha256=snBI6FlFtR03CbYKXwu53R48c_fRSuDIwcNdVUruLcA,21020
 code_puppy/tools/command_runner.py,sha256=3qXVnVTaBPia6y2D29As47_TRKgpyCj82yMFK-8UUYc,44954
-code_puppy/tools/common.py,sha256=IboS6sbwN4a3FzHdfsZJtEFiyDUCszevI6LpH14ydEk,40561
+code_puppy/tools/common.py,sha256=IYf-KOcP5eN2MwTlpULSXNATn7GzloAKl7_M1Uyfe4Y,40360
 code_puppy/tools/file_modifications.py,sha256=vz9n7R0AGDSdLUArZr_55yJLkyI30M8zreAppxIx02M,29380
 code_puppy/tools/file_operations.py,sha256=CqhpuBnOFOcQCIYXOujskxq2VMLWYJhibYrH0YcPSfA,35692
 code_puppy/tools/tools_content.py,sha256=bsBqW-ppd1XNAS_g50B3UHDQBWEALC1UneH6-afz1zo,2365
@@ -174,10 +175,10 @@ code_puppy/tools/browser/browser_scripts.py,sha256=sNb8eLEyzhasy5hV4B9OjM8yIVMLV
 code_puppy/tools/browser/browser_workflows.py,sha256=nitW42vCf0ieTX1gLabozTugNQ8phtoFzZbiAhw1V90,6491
 code_puppy/tools/browser/camoufox_manager.py,sha256=RZjGOEftE5sI_tsercUyXFSZI2wpStXf-q0PdYh2G3I,8680
 code_puppy/tools/browser/vqa_agent.py,sha256=DBn9HKloILqJSTSdNZzH_PYWT0B2h9VwmY6akFQI_uU,2913
-code_puppy-0.0.338.data/data/code_puppy/models.json,sha256=FMQdE_yvP_8y0xxt3K918UkFL9cZMYAqW1SfXcQkU_k,3105
-code_puppy-0.0.338.data/data/code_puppy/models_dev_api.json,sha256=wHjkj-IM_fx1oHki6-GqtOoCrRMR0ScK0f-Iz0UEcy8,548187
-code_puppy-0.0.338.dist-info/METADATA,sha256=kNsGvoJiQpXWHOgGVtrwjkyYvFo8sVRj6xtxXRr83Lw,27520
-code_puppy-0.0.338.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-code_puppy-0.0.338.dist-info/entry_points.txt,sha256=Tp4eQC99WY3HOKd3sdvb22vZODRq0XkZVNpXOag_KdI,91
-code_puppy-0.0.338.dist-info/licenses/LICENSE,sha256=31u8x0SPgdOq3izJX41kgFazWsM43zPEF9eskzqbJMY,1075
-code_puppy-0.0.338.dist-info/RECORD,,
+code_puppy-0.0.340.data/data/code_puppy/models.json,sha256=FMQdE_yvP_8y0xxt3K918UkFL9cZMYAqW1SfXcQkU_k,3105
+code_puppy-0.0.340.data/data/code_puppy/models_dev_api.json,sha256=wHjkj-IM_fx1oHki6-GqtOoCrRMR0ScK0f-Iz0UEcy8,548187
+code_puppy-0.0.340.dist-info/METADATA,sha256=QyW_MkSEm_N8B6ezU2dgW7rkkjI0mTiKhKjn37UEIZU,27550
+code_puppy-0.0.340.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+code_puppy-0.0.340.dist-info/entry_points.txt,sha256=Tp4eQC99WY3HOKd3sdvb22vZODRq0XkZVNpXOag_KdI,91
+code_puppy-0.0.340.dist-info/licenses/LICENSE,sha256=31u8x0SPgdOq3izJX41kgFazWsM43zPEF9eskzqbJMY,1075
+code_puppy-0.0.340.dist-info/RECORD,,