code-puppy 0.0.336__py3-none-any.whl → 0.0.348__py3-none-any.whl

code_puppy/claude_cache_client.py

@@ -9,11 +9,19 @@ serialization, avoiding httpx/Pydantic internals.
 
 from __future__ import annotations
 
+import base64
 import json
-from typing import Any, Callable
+import logging
+import time
+from typing import Any, Callable, MutableMapping
 
 import httpx
 
+logger = logging.getLogger(__name__)
+
+# Refresh token if it's older than 1 hour (3600 seconds)
+TOKEN_MAX_AGE_SECONDS = 3600
+
 try:
     from anthropic import AsyncAnthropic
 except ImportError:  # pragma: no cover - optional dep
@@ -21,9 +29,108 @@ except ImportError:  # pragma: no cover - optional dep
 
 
 class ClaudeCacheAsyncClient(httpx.AsyncClient):
+    def _get_jwt_age_seconds(self, token: str | None) -> float | None:
+        """Decode a JWT and return its age in seconds.
+
+        Returns None if the token can't be decoded or has no timestamp claims.
+        Uses 'iat' (issued at) if available, otherwise calculates from 'exp'.
+        """
+        if not token:
+            return None
+
+        try:
+            # JWT format: header.payload.signature
+            # We only need the payload (second part)
+            parts = token.split(".")
+            if len(parts) != 3:
+                return None
+
+            # Decode the payload (base64url encoded)
+            payload_b64 = parts[1]
+            # Add padding if needed (base64url doesn't require padding)
+            padding = 4 - len(payload_b64) % 4
+            if padding != 4:
+                payload_b64 += "=" * padding
+
+            payload_bytes = base64.urlsafe_b64decode(payload_b64)
+            payload = json.loads(payload_bytes.decode("utf-8"))
+
+            now = time.time()
+
+            # Prefer 'iat' (issued at) claim if available
+            if "iat" in payload:
+                iat = float(payload["iat"])
+                age = now - iat
+                return age
+
+            # Fall back to calculating from 'exp' claim
+            # Assume tokens are typically valid for 1 hour
+            if "exp" in payload:
+                exp = float(payload["exp"])
+                # If exp is in the future, calculate how long until expiry
+                # and assume the token was issued 1 hour before expiry
+                time_until_exp = exp - now
+                # If token has less than 1 hour left, it's "old"
+                age = TOKEN_MAX_AGE_SECONDS - time_until_exp
+                return max(0, age)
+
+            return None
+        except Exception as exc:
+            logger.debug("Failed to decode JWT age: %s", exc)
+            return None
+
+    def _extract_bearer_token(self, request: httpx.Request) -> str | None:
+        """Extract the bearer token from request headers."""
+        auth_header = request.headers.get("Authorization") or request.headers.get(
+            "authorization"
+        )
+        if auth_header and auth_header.lower().startswith("bearer "):
+            return auth_header[7:]  # Strip "Bearer " prefix
+        return None
+
+    def _should_refresh_token(self, request: httpx.Request) -> bool:
+        """Check if the token in the request is older than 1 hour."""
+        token = self._extract_bearer_token(request)
+        if not token:
+            return False
+
+        age = self._get_jwt_age_seconds(token)
+        if age is None:
+            return False
+
+        should_refresh = age >= TOKEN_MAX_AGE_SECONDS
+        if should_refresh:
+            logger.info(
+                "JWT token is %.1f seconds old (>= %d), will refresh proactively",
+                age,
+                TOKEN_MAX_AGE_SECONDS,
+            )
+        return should_refresh
+
     async def send(
         self, request: httpx.Request, *args: Any, **kwargs: Any
     ) -> httpx.Response:  # type: ignore[override]
+        # Proactive token refresh: check JWT age before every request
+        if not request.extensions.get("claude_oauth_refresh_attempted"):
+            try:
+                if self._should_refresh_token(request):
+                    refreshed_token = self._refresh_claude_oauth_token()
+                    if refreshed_token:
+                        logger.info("Proactively refreshed token before request")
+                        # Rebuild request with new token
+                        headers = dict(request.headers)
+                        self._update_auth_headers(headers, refreshed_token)
+                        body_bytes = self._extract_body_bytes(request)
+                        request = self.build_request(
+                            method=request.method,
+                            url=request.url,
+                            headers=headers,
+                            content=body_bytes,
+                        )
+                        request.extensions["claude_oauth_refresh_attempted"] = True
+            except Exception as exc:
+                logger.debug("Error during proactive token refresh check: %s", exc)
+
         try:
             if request.url.path.endswith("/v1/messages"):
                 body_bytes = self._extract_body_bytes(request)
@@ -56,7 +163,47 @@ class ClaudeCacheAsyncClient(httpx.AsyncClient):
         except Exception:
             # Swallow wrapper errors; do not break real calls.
             pass
-        return await super().send(request, *args, **kwargs)
+        response = await super().send(request, *args, **kwargs)
+        try:
+            # 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"
+            ):
+                # 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
     def _extract_body_bytes(request: httpx.Request) -> bytes | None:
@@ -78,6 +225,65 @@ class ClaudeCacheAsyncClient(httpx.AsyncClient):
 
         return None
 
+    @staticmethod
+    def _update_auth_headers(
+        headers: MutableMapping[str, str], access_token: str
+    ) -> None:
+        bearer_value = f"Bearer {access_token}"
+        if "Authorization" in headers or "authorization" in headers:
+            headers["Authorization"] = bearer_value
+        elif "x-api-key" in headers or "X-API-Key" in headers:
+            headers["x-api-key"] = access_token
+        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 as exc:
+            logger.error("Exception during token refresh: %s", exc)
+            return None
+
     @staticmethod
     def _inject_cache_control(body: bytes) -> bytes | None:
         try:

code_puppy/cli_runner.py

@@ -17,14 +17,12 @@ import traceback
 from pathlib import Path
 
 from dbos import DBOS, DBOSConfig
-from rich.console import Console, ConsoleOptions, RenderResult
-from rich.markdown import CodeBlock, Markdown
-from rich.syntax import Syntax
-from rich.text import Text
+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,
@@ -43,6 +41,7 @@ from code_puppy.keymap import (
 )
 from code_puppy.messaging import emit_info
 from code_puppy.terminal_utils import (
+    print_truecolor_warning,
     reset_unix_terminal,
     reset_windows_terminal_ansi,
     reset_windows_terminal_full,
@@ -91,7 +90,6 @@ async def main():
         "command", nargs="*", help="Run a single command (deprecated, use -p instead)"
     )
     args = parser.parse_args()
-    from rich.console import Console
 
     from code_puppy.messaging import (
         RichConsoleRenderer,
@@ -146,6 +144,9 @@ async def main():
         except ImportError:
             emit_system_message("🐶 Code Puppy is Loading...")
 
+        # 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:
         emit_error("No available ports in range 8090-9010!")
@@ -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
@@ -679,8 +699,6 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
             save_command_to_history(task)
 
             try:
-                prettier_code_blocks()
-
                 # No need to get agent directly - use manager's run methods
 
                 # Use our custom helper to enable attachment handling with spinner support
@@ -750,28 +768,6 @@ async def interactive_mode(message_renderer, initial_command: str = None) -> Non
                 pass
 
 
-def prettier_code_blocks():
-    """Configure Rich to use prettier code block rendering."""
-
-    class SimpleCodeBlock(CodeBlock):
-        def __rich_console__(
-            self, console: Console, options: ConsoleOptions
-        ) -> RenderResult:
-            code = str(self.text).rstrip()
-            yield Text(self.lexer_name, style="dim")
-            syntax = Syntax(
-                code,
-                self.lexer_name,
-                theme=self.theme,
-                background_color="default",
-                line_numbers=True,
-            )
-            yield syntax
-            yield Text(f"/{self.lexer_name}", style="dim")
-
-    Markdown.elements["fence"] = SimpleCodeBlock
-
-
 async def run_prompt_with_attachments(
     agent,
     raw_prompt: str,
@@ -785,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
 
@@ -793,33 +790,54 @@ 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
+    # IMPORTANT: Set the shared console for streaming output so it
     # uses the same console as the spinner. This prevents Live display conflicts
     # that cause line duplication during markdown streaming.
-    if spinner_console is not None:
-        agent._console = spinner_console
+    from code_puppy.agents.event_stream_handler import set_streaming_console
+
+    set_streaming_console(spinner_console)
 
     # 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/add_model_menu.py

@@ -17,6 +17,7 @@ from prompt_toolkit.layout import Dimension, Layout, VSplit, Window
 from prompt_toolkit.layout.controls import FormattedTextControl
 from prompt_toolkit.widgets import Frame
 
+from code_puppy.command_line.utils import safe_input
 from code_puppy.config import EXTRA_MODELS_FILE, set_config_value
 from code_puppy.messaging import emit_error, emit_info, emit_warning
 from code_puppy.models_dev_parser import ModelInfo, ModelsDevRegistry, ProviderInfo
@@ -724,8 +725,8 @@ class AddModelMenu:
                 emit_info(f"  {hint}")
 
             try:
-                # Use regular input - simpler and works in threaded context
-                value = input(f"  Enter {env_var} (or press Enter to skip): ").strip()
+                # Use safe_input for cross-platform compatibility (Windows fix)
+                value = safe_input(f"  Enter {env_var} (or press Enter to skip): ")
 
                 if not value:
                     emit_warning(
@@ -785,7 +786,7 @@ class AddModelMenu:
         )
 
         try:
-            model_name = input("  Model ID: ").strip()
+            model_name = safe_input("  Model ID: ")
 
             if not model_name:
                 emit_warning("No model name provided, cancelled.")
@@ -795,7 +796,7 @@ class AddModelMenu:
             emit_info("\n  Enter the context window size (in tokens).")
             emit_info("  Common sizes: 8192, 32768, 128000, 200000, 1000000\n")
 
-            context_input = input("  Context size [128000]: ").strip()
+            context_input = safe_input("  Context size [128000]: ")
 
             if not context_input:
                 context_length = 128000  # Default
@@ -1045,11 +1046,9 @@ class AddModelMenu:
                     f"   It will be very limited for coding tasks."
                 )
                 try:
-                    confirm = (
-                        input("\n  Are you sure you want to add this model? (y/N): ")
-                        .strip()
-                        .lower()
-                    )
+                    confirm = safe_input(
+                        "\n  Are you sure you want to add this model? (y/N): "
+                    ).lower()
                     if confirm not in ("y", "yes"):
                         emit_info("Model addition cancelled.")
                         return False

code_puppy/command_line/autosave_menu.py

@@ -69,12 +69,21 @@ def _get_session_entries(base_dir: Path) -> List[Tuple[str, dict]]:
 
 
 def _extract_last_user_message(history: list) -> str:
-    """Extract the most recent user message from history."""
+    """Extract the most recent user message from history.
+
+    Joins all content parts from the message since messages can have
+    multiple parts (e.g., text + attachments, multi-part prompts).
+    """
     # Walk backwards through history to find last user message
     for msg in reversed(history):
+        content_parts = []
         for part in msg.parts:
             if hasattr(part, "content"):
-                return part.content
+                content = part.content
+                if isinstance(content, str) and content.strip():
+                    content_parts.append(content)
+        if content_parts:
+            return "\n\n".join(content_parts)
     return "[No messages found]"
 
 
@@ -298,19 +307,13 @@ def _render_message_browser_panel(
             # Don't override Rich's ANSI styling - use empty style
             text_color = ""
 
-        # Truncate if too long (max 35 lines)
-        message_lines = rendered.split("\n")[:35]
-        is_truncated = len(rendered.split("\n")) > 35
+        # Show full message without truncation
+        message_lines = rendered.split("\n")
 
         for line in message_lines:
             lines.append((text_color, f"  {line}"))
             lines.append(("", "\n"))
 
-        if is_truncated:
-            lines.append(("", "\n"))
-            lines.append(("fg:yellow", "  ... truncated (message too long)"))
-            lines.append(("", "\n"))
-
     except Exception as e:
         lines.append(("fg:red", f"  Error rendering message: {e}"))
         lines.append(("", "\n"))
@@ -359,7 +362,7 @@ def _render_preview_panel(base_dir: Path, entry: Optional[Tuple[str, dict]]) ->
     lines.append(("", "\n\n"))
 
     lines.append(("bold", "  Last Message:"))
-    lines.append(("fg:ansibrightblack", "  (press 'e' to browse all)"))
+    lines.append(("fg:ansibrightblack", "  (press 'e' to browse full history)"))
     lines.append(("", "\n"))
 
     # Try to load and preview the last message
@@ -367,15 +370,11 @@ def _render_preview_panel(base_dir: Path, entry: Optional[Tuple[str, dict]]) ->
         history = load_session(session_name, base_dir)
         last_message = _extract_last_user_message(history)
 
-        # Check if original message is long (before Rich processing)
-        original_lines = last_message.split("\n") if last_message else []
-        is_long = len(original_lines) > 30
-
-        # Render markdown with rich but strip ANSI codes
+        # Render markdown with rich
         console = Console(
             file=StringIO(),
             legacy_windows=False,
-            no_color=False,  # Disable ANSI color codes
+            no_color=False,
             force_terminal=False,
             width=76,
         )
@@ -383,19 +382,14 @@ def _render_preview_panel(base_dir: Path, entry: Optional[Tuple[str, dict]]) ->
         console.print(md)
         rendered = console.file.getvalue()
 
-        # Truncate if too long (max 30 lines for bigger preview)
-        message_lines = rendered.split("\n")[:30]
+        # Show full message without truncation
+        message_lines = rendered.split("\n")
 
         for line in message_lines:
             # Rich already rendered the markdown, just display it dimmed
             lines.append(("fg:ansibrightblack", f"  {line}"))
             lines.append(("", "\n"))
 
-        if is_long:
-            lines.append(("", "\n"))
-            lines.append(("fg:yellow", "  ... truncated"))
-            lines.append(("", "\n"))
-
     except Exception as e:
         lines.append(("fg:red", f"  Error loading preview: {e}"))
         lines.append(("", "\n"))