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

code_puppy/messaging/message_queue.py

@@ -329,31 +329,19 @@ def emit_divider(content: str = "─" * 100 + "\n", **metadata):
 
 
 def emit_prompt(prompt_text: str, timeout: float = None) -> str:
-    """Emit a human input request and wait for response."""
-    # TUI mode has been removed, always use interactive mode input
-    if True:
-        # Emit the prompt as a message for display
-        from code_puppy.messaging import emit_info
+    """Emit a human input request and wait for response.
 
-        emit_info(prompt_text)
+    Uses safe_input for cross-platform compatibility, especially on Windows
+    where raw input() can fail after prompt_toolkit Applications.
+    """
+    from code_puppy.command_line.utils import safe_input
+    from code_puppy.messaging import emit_info
 
-        # Get input directly
-        try:
-            # Try to use rich console for better formatting
-            from rich.console import Console
-
-            console = Console()
-            response = console.input("[cyan]>>> [/cyan]")
-            return response
-        except Exception:
-            # Fallback to basic input
-            response = input(">>> ")
-            return response
-
-    # In TUI mode, use the queue system
-    queue = get_global_queue()
-    prompt_id = queue.create_prompt_request(prompt_text)
-    return queue.wait_for_prompt_response(prompt_id, timeout)
+    emit_info(prompt_text)
+
+    # Use safe_input which resets Windows console state before reading
+    response = safe_input(">>> ")
+    return response
 
 
 def provide_prompt_response(prompt_id: str, response: str):

code_puppy/messaging/messages.py

@@ -209,6 +209,9 @@ class ShellStartMessage(BaseMessage):
         default=None, description="Working directory for the command"
     )
     timeout: int = Field(default=60, description="Timeout in seconds")
+    background: bool = Field(
+        default=False, description="Whether command runs in background mode"
+    )
 
 
 class ShellLineMessage(BaseMessage):

code_puppy/messaging/rich_renderer.py

@@ -620,15 +620,25 @@ class RichConsoleRenderer:
         safe_command = escape_rich_markup(msg.command)
         # Header showing command is starting
         banner = self._format_banner("shell_command", "SHELL COMMAND")
-        self._console.print(f"\n{banner} 🚀 [dim]$ {safe_command}[/dim]")
+
+        # Add background indicator if running in background mode
+        if msg.background:
+            self._console.print(
+                f"\n{banner} 🚀 [dim]$ {safe_command}[/dim]  [bold magenta][BACKGROUND 🌙][/bold magenta]"
+            )
+        else:
+            self._console.print(f"\n{banner} 🚀 [dim]$ {safe_command}[/dim]")
 
         # Show working directory if specified
         if msg.cwd:
             safe_cwd = escape_rich_markup(msg.cwd)
             self._console.print(f"[dim]📂 Working directory: {safe_cwd}[/dim]")
 
-        # Show timeout
-        self._console.print(f"[dim]⏱ Timeout: {msg.timeout}s[/dim]")
+        # Show timeout or background status
+        if msg.background:
+            self._console.print("[dim]⏱ Runs detached (no timeout)[/dim]")
+        else:
+            self._console.print(f"[dim]⏱ Timeout: {msg.timeout}s[/dim]")
 
     def _render_shell_line(self, msg: ShellLineMessage) -> None:
         """Render shell output line preserving ANSI codes."""

code_puppy/model_factory.py

@@ -388,6 +388,20 @@ class ModelFactory:
             return AnthropicModel(model_name=model_config["name"], provider=provider)
         elif model_type == "claude_code":
             url, headers, verify, api_key = get_custom_config(model_config)
+            if model_config.get("oauth_source") == "claude-code-plugin":
+                try:
+                    from code_puppy.plugins.claude_code_oauth.utils import (
+                        get_valid_access_token,
+                    )
+
+                    refreshed_token = get_valid_access_token()
+                    if refreshed_token:
+                        api_key = refreshed_token
+                        custom_endpoint = model_config.get("custom_endpoint")
+                        if isinstance(custom_endpoint, dict):
+                            custom_endpoint["api_key"] = refreshed_token
+                except ImportError:
+                    pass
             if not api_key:
                 emit_warning(
                     f"API key is not set for Claude Code endpoint; skipping model '{model_config.get('name')}'."
@@ -663,6 +677,8 @@ class ModelFactory:
                     f"API key is not set for Cerebras endpoint; skipping model '{model_config.get('name')}'."
                 )
                 return None
+            # Add Cerebras 3rd party integration header
+            headers["X-Cerebras-3rd-Party-Integration"] = "code-puppy"
             client = create_async_client(headers=headers, verify=verify)
             provider_args = dict(
                 api_key=api_key,

code_puppy/models.json

@@ -55,9 +55,9 @@
     "supported_settings": ["reasoning_effort", "verbosity"],
     "supports_xhigh_reasoning": true
   },
-  "Cerebras-GLM-4.6": {
+  "Cerebras-GLM-4.7": {
     "type": "cerebras",
-    "name": "zai-glm-4.6",
+    "name": "zai-glm-4.7",
     "custom_endpoint": {
       "url": "https://api.cerebras.ai/v1",
       "api_key": "$CEREBRAS_API_KEY"

code_puppy/plugins/antigravity_oauth/antigravity_model.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import base64
 import json
 import logging
 from collections.abc import AsyncIterator
@@ -75,7 +76,16 @@ class AntigravityModel(GoogleModel):
                         system_parts.append({"text": part.content})
                     elif isinstance(part, UserPromptPart):
                         # Use parent's _map_user_prompt
-                        message_parts.extend(await self._map_user_prompt(part))
+                        mapped_parts = await self._map_user_prompt(part)
+                        # Sanitize bytes to base64 for JSON serialization
+                        for mp in mapped_parts:
+                            if "inline_data" in mp and "data" in mp["inline_data"]:
+                                data = mp["inline_data"]["data"]
+                                if isinstance(data, bytes):
+                                    mp["inline_data"]["data"] = base64.b64encode(
+                                        data
+                                    ).decode("utf-8")
+                        message_parts.extend(mapped_parts)
                     elif isinstance(part, ToolReturnPart):
                         message_parts.append(
                             {
@@ -542,8 +552,13 @@ def _antigravity_content_model_response(
 
         elif isinstance(item, FilePart):
             content = item.content
+            # Ensure data is base64 string, not bytes
+            data_val = content.data
+            if isinstance(data_val, bytes):
+                data_val = base64.b64encode(data_val).decode("utf-8")
+
             inline_data_dict: BlobDict = {
-                "data": content.data,
+                "data": data_val,
                 "mime_type": content.media_type,
             }
             part["inline_data"] = inline_data_dict

code_puppy/plugins/claude_code_oauth/utils.py

@@ -21,6 +21,8 @@ from .config import (
     get_token_storage_path,
 )
 
+TOKEN_REFRESH_BUFFER_SECONDS = 60
+
 logger = logging.getLogger(__name__)
 
 
@@ -132,6 +134,124 @@ def load_stored_tokens() -> Optional[Dict[str, Any]]:
     return None
 
 
+def _calculate_expires_at(expires_in: Optional[float]) -> Optional[float]:
+    if expires_in is None:
+        return None
+    try:
+        return time.time() + float(expires_in)
+    except (TypeError, ValueError):
+        return None
+
+
+def is_token_expired(tokens: Dict[str, Any]) -> bool:
+    expires_at = tokens.get("expires_at")
+    if expires_at is None:
+        return False
+    try:
+        expires_at_value = float(expires_at)
+    except (TypeError, ValueError):
+        return False
+    return time.time() >= expires_at_value - TOKEN_REFRESH_BUFFER_SECONDS
+
+
+def update_claude_code_model_tokens(access_token: str) -> bool:
+    try:
+        claude_models = load_claude_models()
+        if not claude_models:
+            return False
+
+        updated = False
+        for config in claude_models.values():
+            if config.get("oauth_source") != "claude-code-plugin":
+                continue
+            custom_endpoint = config.get("custom_endpoint")
+            if not isinstance(custom_endpoint, dict):
+                continue
+            custom_endpoint["api_key"] = access_token
+            updated = True
+
+        if updated:
+            return save_claude_models(claude_models)
+    except Exception as exc:  # pragma: no cover - defensive logging
+        logger.error("Failed to update Claude model tokens: %s", exc)
+    return False
+
+
+def refresh_access_token(force: bool = False) -> Optional[str]:
+    tokens = load_stored_tokens()
+    if not tokens:
+        return None
+
+    if not force and not is_token_expired(tokens):
+        return tokens.get("access_token")
+
+    refresh_token = tokens.get("refresh_token")
+    if not refresh_token:
+        logger.debug("No refresh_token available")
+        return None
+
+    payload = {
+        "grant_type": "refresh_token",
+        "client_id": CLAUDE_CODE_OAUTH_CONFIG["client_id"],
+        "refresh_token": refresh_token,
+    }
+
+    headers = {
+        "Content-Type": "application/json",
+        "Accept": "application/json",
+        "anthropic-beta": "oauth-2025-04-20",
+    }
+
+    try:
+        response = requests.post(
+            CLAUDE_CODE_OAUTH_CONFIG["token_url"],
+            json=payload,
+            headers=headers,
+            timeout=30,
+        )
+        if response.status_code == 200:
+            new_tokens = response.json()
+            tokens["access_token"] = new_tokens.get("access_token")
+            tokens["refresh_token"] = new_tokens.get("refresh_token", refresh_token)
+            if "expires_in" in new_tokens:
+                tokens["expires_in"] = new_tokens["expires_in"]
+                tokens["expires_at"] = _calculate_expires_at(
+                    new_tokens.get("expires_in")
+                )
+            if save_tokens(tokens):
+                update_claude_code_model_tokens(tokens["access_token"])
+                return tokens["access_token"]
+        else:
+            logger.error(
+                "Token refresh failed: %s - %s", response.status_code, response.text
+            )
+    except Exception as exc:  # pragma: no cover - defensive logging
+        logger.error("Token refresh error: %s", exc)
+    return None
+
+
+def get_valid_access_token() -> Optional[str]:
+    tokens = load_stored_tokens()
+    if not tokens:
+        logger.debug("No stored Claude Code OAuth tokens found")
+        return None
+
+    access_token = tokens.get("access_token")
+    if not access_token:
+        logger.debug("No access_token in stored tokens")
+        return None
+
+    if is_token_expired(tokens):
+        logger.info("Claude Code OAuth token expired, attempting refresh")
+        refreshed = refresh_access_token()
+        if refreshed:
+            return refreshed
+        logger.warning("Claude Code token refresh failed")
+        return None
+
+    return access_token
+
+
 def save_tokens(tokens: Dict[str, Any]) -> bool:
     try:
         token_path = get_token_storage_path()
@@ -243,7 +363,11 @@ def exchange_code_for_tokens(
         logger.info("Token exchange response: %s", response.status_code)
         logger.debug("Response body: %s", response.text)
         if response.status_code == 200:
-            return response.json()
+            token_data = response.json()
+            token_data["expires_at"] = _calculate_expires_at(
+                token_data.get("expires_in")
+            )
+            return token_data
         logger.error(
             "Token exchange failed: %s - %s",
             response.status_code,
@@ -341,12 +465,7 @@ def add_models_to_extra_config(models: List[str]) -> bool:
         # Start fresh - overwrite the file on every auth instead of loading existing
         claude_models = {}
         added = 0
-        tokens = load_stored_tokens()
-
-        # Handle case where tokens are None or empty
-        access_token = ""
-        if tokens and "access_token" in tokens:
-            access_token = tokens["access_token"]
+        access_token = get_valid_access_token() or ""
 
         for model_name in filtered_models:
             prefixed = f"{CLAUDE_CODE_OAUTH_CONFIG['prefix']}{model_name}"

code_puppy/terminal_utils.py

@@ -3,10 +3,14 @@
 Handles Windows console mode resets and Unix terminal sanity restoration.
 """
 
+import os
 import platform
 import subprocess
 import sys
-from typing import Callable, Optional
+from typing import TYPE_CHECKING, Callable, Optional
+
+if TYPE_CHECKING:
+    from rich.console import Console
 
 # Store the original console ctrl handler so we can restore it if needed
 _original_ctrl_handler: Optional[Callable] = None
@@ -289,3 +293,126 @@ def ensure_ctrl_c_disabled() -> bool:
 
     except Exception:
         return False
+
+
+def detect_truecolor_support() -> bool:
+    """Detect if the terminal supports truecolor (24-bit color).
+
+    Checks multiple indicators:
+    1. COLORTERM environment variable (most reliable)
+    2. TERM environment variable patterns
+    3. Rich's Console color_system detection as fallback
+
+    Returns:
+        True if truecolor is supported, False otherwise.
+    """
+    # Check COLORTERM - this is the most reliable indicator
+    colorterm = os.environ.get("COLORTERM", "").lower()
+    if colorterm in ("truecolor", "24bit"):
+        return True
+
+    # Check TERM for known truecolor-capable terminals
+    term = os.environ.get("TERM", "").lower()
+    truecolor_terms = (
+        "xterm-direct",
+        "xterm-truecolor",
+        "iterm2",
+        "vte-256color",  # Many modern terminals set this
+    )
+    if any(t in term for t in truecolor_terms):
+        return True
+
+    # Some terminals like iTerm2, Kitty, Alacritty set specific env vars
+    if os.environ.get("ITERM_SESSION_ID"):
+        return True
+    if os.environ.get("KITTY_WINDOW_ID"):
+        return True
+    if os.environ.get("ALACRITTY_SOCKET"):
+        return True
+    if os.environ.get("WT_SESSION"):  # Windows Terminal
+        return True
+
+    # Use Rich's detection as a fallback
+    try:
+        from rich.console import Console
+
+        console = Console(force_terminal=True)
+        color_system = console.color_system
+        return color_system == "truecolor"
+    except Exception:
+        pass
+
+    return False
+
+
+def print_truecolor_warning(console: Optional["Console"] = None) -> None:
+    """Print a big fat red warning if truecolor is not supported.
+
+    Args:
+        console: Optional Rich Console instance. If None, creates a new one.
+    """
+    if detect_truecolor_support():
+        return  # All good, no warning needed
+
+    if console is None:
+        try:
+            from rich.console import Console
+
+            console = Console()
+        except ImportError:
+            # Rich not available, fall back to plain print
+            print("\n" + "=" * 70)
+            print("⚠️  WARNING: TERMINAL DOES NOT SUPPORT TRUECOLOR (24-BIT COLOR)")
+            print("=" * 70)
+            print("Code Puppy looks best with truecolor support.")
+            print("Consider using a modern terminal like:")
+            print("  • iTerm2 (macOS)")
+            print("  • Windows Terminal (Windows)")
+            print("  • Kitty, Alacritty, or any modern terminal emulator")
+            print("")
+            print("You can also try setting: export COLORTERM=truecolor")
+            print("")
+            print("Note: The built-in macOS Terminal.app does not support truecolor")
+            print("(Sequoia and earlier). You'll need a different terminal app.")
+            print("=" * 70 + "\n")
+            return
+
+    # Get detected color system for diagnostic info
+    color_system = console.color_system or "unknown"
+
+    # Build the warning box
+    warning_lines = [
+        "",
+        "[bold bright_red on red]" + "━" * 72 + "[/]",
+        "[bold bright_red on red]┃[/][bold bright_white on red]"
+        + " " * 70
+        + "[/][bold bright_red on red]┃[/]",
+        "[bold bright_red on red]┃[/][bold bright_white on red]  ⚠️   WARNING: TERMINAL DOES NOT SUPPORT TRUECOLOR (24-BIT COLOR)  ⚠️   [/][bold bright_red on red]┃[/]",
+        "[bold bright_red on red]┃[/][bold bright_white on red]"
+        + " " * 70
+        + "[/][bold bright_red on red]┃[/]",
+        "[bold bright_red on red]" + "━" * 72 + "[/]",
+        "",
+        f"[yellow]Detected color system:[/] [bold]{color_system}[/]",
+        "",
+        "[bold white]Code Puppy uses rich colors and will look degraded without truecolor.[/]",
+        "",
+        "[cyan]Consider using a modern terminal emulator:[/]",
+        "  [green]•[/] [bold]iTerm2[/] (macOS) - https://iterm2.com",
+        "  [green]•[/] [bold]Windows Terminal[/] (Windows) - Built into Windows 11",
+        "  [green]•[/] [bold]Kitty[/] - https://sw.kovidgoyal.net/kitty",
+        "  [green]•[/] [bold]Alacritty[/] - https://alacritty.org",
+        "  [green]•[/] [bold]Warp[/] (macOS) - https://warp.dev",
+        "",
+        "[cyan]Or try setting the COLORTERM environment variable:[/]",
+        "  [dim]export COLORTERM=truecolor[/]",
+        "",
+        "[dim italic]Note: The built-in macOS Terminal.app does not support truecolor (Sequoia and earlier).[/]",
+        "[dim italic]Setting COLORTERM=truecolor won't help - you'll need a different terminal app.[/]",
+        "",
+        "[bold bright_red]" + "─" * 72 + "[/]",
+        "",
+    ]
+
+    for line in warning_lines:
+        console.print(line)

code_puppy/tools/agent_tools.py

@@ -21,6 +21,7 @@ from code_puppy.config import (
     DATA_DIR,
     get_message_limit,
     get_use_dbos,
+    get_value,
 )
 from code_puppy.messaging import (
     SubAgentInvocationMessage,
@@ -471,39 +472,90 @@ def register_invoke_agent(agent):
             subagent_name = f"temp-invoke-agent-{session_id}"
             model_settings = make_model_settings(model_name)
 
-            temp_agent = Agent(
-                model=model,
-                instructions=instructions,
-                output_type=str,
-                retries=3,
-                history_processors=[agent_config.message_history_accumulator],
-                model_settings=model_settings,
-            )
+            # Get MCP servers for sub-agents (same as main agent)
+            from code_puppy.mcp_ import get_mcp_manager
 
-            # Register the tools that the agent needs
-            from code_puppy.tools import register_tools_for_agent
+            mcp_servers = []
+            mcp_disabled = get_value("disable_mcp_servers")
+            if not (
+                mcp_disabled and str(mcp_disabled).lower() in ("1", "true", "yes", "on")
+            ):
+                manager = get_mcp_manager()
+                mcp_servers = manager.get_servers_for_agent()
 
-            agent_tools = agent_config.get_available_tools()
-            register_tools_for_agent(temp_agent, agent_tools)
+            # Get the event_stream_handler for streaming output
+            from code_puppy.agents.event_stream_handler import event_stream_handler
 
             if get_use_dbos():
                 from pydantic_ai.durable_exec.dbos import DBOSAgent
 
-                dbos_agent = DBOSAgent(temp_agent, name=subagent_name)
+                # For DBOS, create agent without MCP servers (to avoid serialization issues)
+                # and add them at runtime
+                temp_agent = Agent(
+                    model=model,
+                    instructions=instructions,
+                    output_type=str,
+                    retries=3,
+                    toolsets=[],  # MCP servers added separately for DBOS
+                    history_processors=[agent_config.message_history_accumulator],
+                    model_settings=model_settings,
+                )
+
+                # Register the tools that the agent needs
+                from code_puppy.tools import register_tools_for_agent
+
+                agent_tools = agent_config.get_available_tools()
+                register_tools_for_agent(temp_agent, agent_tools)
+
+                # Wrap with DBOS - pass event_stream_handler for streaming output
+                dbos_agent = DBOSAgent(
+                    temp_agent,
+                    name=subagent_name,
+                    event_stream_handler=event_stream_handler,
+                )
                 temp_agent = dbos_agent
 
+                # Store MCP servers to add at runtime
+                subagent_mcp_servers = mcp_servers
+            else:
+                # Non-DBOS path - include MCP servers directly in the agent
+                temp_agent = Agent(
+                    model=model,
+                    instructions=instructions,
+                    output_type=str,
+                    retries=3,
+                    toolsets=mcp_servers,
+                    history_processors=[agent_config.message_history_accumulator],
+                    model_settings=model_settings,
+                )
+
+                # Register the tools that the agent needs
+                from code_puppy.tools import register_tools_for_agent
+
+                agent_tools = agent_config.get_available_tools()
+                register_tools_for_agent(temp_agent, agent_tools)
+
+                subagent_mcp_servers = None
+
             # Run the temporary agent with the provided prompt as an asyncio task
             # Pass the message_history from the session to continue the conversation
             workflow_id = None  # Track for potential cancellation
             if get_use_dbos():
                 # Generate a unique workflow ID for DBOS - ensures no collisions in back-to-back calls
                 workflow_id = _generate_dbos_workflow_id(group_id)
+
+                # Add MCP servers to the DBOS agent's toolsets
+                # (temp_agent is discarded after this invocation, so no need to restore)
+                if subagent_mcp_servers:
+                    temp_agent._toolsets = temp_agent._toolsets + subagent_mcp_servers
+
                 with SetWorkflowID(workflow_id):
                     task = asyncio.create_task(
                         temp_agent.run(
                             prompt,
                             message_history=message_history,
                             usage_limits=UsageLimits(request_limit=get_message_limit()),
+                            event_stream_handler=event_stream_handler,
                         )
                     )
                     _active_subagent_tasks.add(task)
@@ -513,6 +565,7 @@ def register_invoke_agent(agent):
                         prompt,
                         message_history=message_history,
                         usage_limits=UsageLimits(request_limit=get_message_limit()),
+                        event_stream_handler=event_stream_handler,
                     )
                 )
                 _active_subagent_tasks.add(task)

code_puppy/tools/command_runner.py

@@ -880,6 +880,7 @@ async def run_shell_command(
                     command=command,
                     cwd=cwd,
                     timeout=0,  # No timeout for background processes
+                    background=True,
                 )
             )
 

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.336.data → code_puppy-0.0.348.data}/data/code_puppy/models.json

@@ -55,9 +55,9 @@
     "supported_settings": ["reasoning_effort", "verbosity"],
     "supports_xhigh_reasoning": true
   },
-  "Cerebras-GLM-4.6": {
+  "Cerebras-GLM-4.7": {
     "type": "cerebras",
-    "name": "zai-glm-4.6",
+    "name": "zai-glm-4.7",
     "custom_endpoint": {
       "url": "https://api.cerebras.ai/v1",
       "api_key": "$CEREBRAS_API_KEY"