Merge test-verify-agent-clean into cli-user-skill and fix CLI tests

Author: tosincarik

.github/workflows/cli-build-binary-and-optionally-release.yml

@@ -7,7 +7,7 @@ on:
     push:
         branches: [main]
         tags:
-            - '*-cli'
+            - '*'
     pull_request:
         branches: ['**']
 

.github/workflows/pypi-release.yml

@@ -22,10 +22,10 @@ jobs:
         runs-on: blacksmith-2vcpu-ubuntu-2404
         permissions:
             id-token: write
-    # Run when manually dispatched for "cli" OR for tag pushes that contain '-cli'
+    # Run when manually dispatched for "cli" OR for any tag pushes
         if: |
             (github.event_name == 'workflow_dispatch' && github.event.inputs.reason == 'cli')
-            || (github.event_name == 'push' && startsWith(github.ref, 'refs/tags/') && contains(github.ref, '-cli'))
+            || (github.event_name == 'push' && startsWith(github.ref, 'refs/tags/'))
         steps:
             - name: Checkout repository
               uses: actions/checkout@v4

openhands_cli/acp_impl/event.py

@@ -52,7 +52,23 @@
     TaskTrackerObservation,
     TaskTrackerStatusType,
 )
-from openhands.tools.terminal.definition import TerminalAction
+
+
+try:
+    from openhands.tools.terminal.definition import TerminalAction
+except ModuleNotFoundError:  # e.g. missing fcntl on Windows
+
+    class _TerminalActionStub:
+        """Fallback TerminalAction stub for platforms without terminal backend.
+
+        This allows ACP event processing code and tests to import on Windows
+        where the underlying openhands terminal implementation depends on
+        fcntl, which is unavailable.
+        """
+
+        command: str | None = None
+
+    TerminalAction = _TerminalActionStub  # type: ignore[assignment]
 
 
 logger = get_logger(__name__)

openhands_cli/agent_chat.py

@@ -66,7 +66,6 @@ def run_cli_entry(
 ) -> None:
     """Run the agent chat session using the agent SDK.
 
-
     Raises:
         AgentSetupError: If agent setup fails
         KeyboardInterrupt: If user interrupts the session

openhands_cli/setup.py

@@ -1,25 +1,38 @@
 from typing import Any
 from uuid import UUID
-import uuid
 
-from openhands.sdk.conversation import visualizer
-from openhands.sdk.security.llm_analyzer import LLMSecurityAnalyzer
 from prompt_toolkit import HTML, print_formatted_text
 
 from openhands.sdk import Agent, BaseConversation, Conversation, Workspace
 from openhands.sdk.context import AgentContext, Skill
-from openhands_cli.locations import CONVERSATIONS_DIR, WORK_DIR
-from openhands_cli.tui.settings.store import AgentStore
-from openhands.sdk.security.confirmation_policy import (
-    AlwaysConfirm,
+from openhands.sdk.conversation import (
+    visualizer,  # noqa: F401 (ensures tools registered)
 )
+from openhands.sdk.security.confirmation_policy import AlwaysConfirm
+from openhands.sdk.security.llm_analyzer import LLMSecurityAnalyzer
+from openhands_cli.locations import CONVERSATIONS_DIR, WORK_DIR
 from openhands_cli.tui.settings.settings_screen import SettingsScreen
+from openhands_cli.tui.settings.store import AgentStore
 from openhands_cli.tui.visualizer import CLIVisualizer
 
+
 # register tools
-from openhands.tools.terminal import TerminalTool
-from openhands.tools.file_editor import FileEditorTool
-from openhands.tools.task_tracker import TaskTrackerTool
+try:
+    from openhands.tools.file_editor import (
+        FileEditorTool,  # type: ignore[attr-defined]  # noqa: F401
+    )
+    from openhands.tools.task_tracker import (
+        TaskTrackerTool,  # type: ignore[attr-defined]  # noqa: F401
+    )
+    from openhands.tools.terminal import (
+        TerminalTool,  # type: ignore[attr-defined]  # noqa: F401
+    )
+except ModuleNotFoundError:
+    # Some platforms (e.g., Windows) may not have all low-level deps like fcntl.
+    # The core CLI and tests don't require these tools at import time.
+    TerminalTool = None  # type: ignore[assignment]
+    FileEditorTool = None  # type: ignore[assignment]
+    TaskTrackerTool = None  # type: ignore[assignment]
 
 
 class MissingAgentSpec(Exception):
@@ -28,83 +41,95 @@ class MissingAgentSpec(Exception):
     pass
 
 
-
 def load_agent_specs(
     conversation_id: str | None = None,
-    *,
-    load_user_skills: bool = True,
-    load_project_skills: bool = True,
+    mcp_servers: dict[str, dict[str, Any]] | None = None,
+    skills: list[Skill] | None = None,
 ) -> Agent:
+    """Load agent specifications.
+
+    Args:
+        conversation_id: Optional conversation ID for session tracking
+        mcp_servers: Optional dict of MCP servers to augment agent configuration
+        skills: Optional list of skills to include in the agent configuration
+
+    Returns:
+        Configured Agent instance
+
+    Raises:
+        MissingAgentSpec: If agent specification is not found or invalid
+    """
     agent_store = AgentStore()
-    agent = agent_store.load(
-        session_id=conversation_id,
-        load_user_skills=load_user_skills,
-        load_project_skills=load_project_skills,
-    )
+    agent = agent_store.load(session_id=conversation_id)
     if not agent:
         raise MissingAgentSpec(
-            'Agent specification not found. Please configure your agent settings.'
+            "Agent specification not found. Please configure your agent settings."
         )
+
+    # If MCP servers are provided, augment the agent's MCP configuration
+    if mcp_servers:
+        # Merge with existing MCP configuration (provided servers take precedence)
+        mcp_config: dict[str, Any] = agent.mcp_config or {}
+        existing_servers: dict[str, dict[str, Any]] = mcp_config.get("mcpServers", {})
+        existing_servers.update(mcp_servers)
+        agent = agent.model_copy(
+            update={"mcp_config": {"mcpServers": existing_servers}}
+        )
+
+    if skills:
+        if agent.agent_context is not None:
+            existing_skills = agent.agent_context.skills
+            existing_skills.extend(skills)
+            agent = agent.model_copy(
+                update={
+                    "agent_context": agent.agent_context.model_copy(
+                        update={"skills": existing_skills}
+                    )
+                }
+            )
+        else:
+            agent = agent.model_copy(
+                update={"agent_context": AgentContext(skills=skills)}
+            )
+
     return agent
 
 
-def verify_agent_exists_or_setup_agent(
-    *,
-    load_user_skills: bool = True,
-    load_project_skills: bool = True,
-) -> Agent:
+def verify_agent_exists_or_setup_agent() -> Agent:
     """Verify agent specs exists by attempting to load it.
 
+    If missing, run the settings flow and try once more.
     """
     settings_screen = SettingsScreen()
     try:
-        agent = load_agent_specs(
-            load_user_skills=load_user_skills,
-            load_project_skills=load_project_skills,
-        )
+        agent = load_agent_specs()
         return agent
     except MissingAgentSpec:
-        # For first-time users, show the full settings flow with choice between basic/advanced
+        # For first-time users, show the full settings flow with
+        # choice between basic/advanced
         settings_screen.configure_settings(first_time=True)
 
-
     # Try once again after settings setup attempt
-    return load_agent_specs(
-        load_user_skills=load_user_skills,
-        load_project_skills=load_project_skills,
-    )
+    return load_agent_specs()
 
 
 def setup_conversation(
     conversation_id: UUID,
     include_security_analyzer: bool = True,
-    *,
-    load_user_skills: bool = True,
-    load_project_skills: bool = True,
-    mcp_servers: dict[str, dict[str, Any]] | None = None,
-    skills: list[Skill] | None = None,
 ) -> BaseConversation:
-    """
-    Setup the conversation with agent.
+    """Setup the conversation with agent.
 
     Args:
-        conversation_id: conversation ID to use. If not provided, a random UUID will be generated.
+        conversation_id: conversation ID to use.
+            If not provided, a random UUID will be generated.
 
     Raises:
         MissingAgentSpec: If agent specification is not found or invalid.
     """
 
-    print_formatted_text(
-        HTML(f'<white>Initializing agent...</white>')
-    )
-
-    agent = load_agent_specs(
-        str(conversation_id),
-        load_user_skills=load_user_skills,
-        load_project_skills=load_project_skills,
-    )
-
+    print_formatted_text(HTML("<white>Initializing agent...</white>"))
 
+    agent = load_agent_specs(str(conversation_id))
 
     # Create conversation - agent context is now set in AgentStore.load()
     conversation: BaseConversation = Conversation(
@@ -113,7 +138,7 @@ def setup_conversation(
         # Conversation will add /<conversation_id> to this path
         persistence_dir=CONVERSATIONS_DIR,
         conversation_id=conversation_id,
-        visualizer=CLIVisualizer
+        visualizer=CLIVisualizer,
     )
 
     # Security analyzer is set though conversation API now
@@ -124,6 +149,6 @@ def setup_conversation(
         conversation.set_confirmation_policy(AlwaysConfirm())
 
     print_formatted_text(
-        HTML(f'<green>✓ Agent initialized with model: {agent.llm.model}</green>')
+        HTML(f"<green>✓ Agent initialized with model: {agent.llm.model}</green>")
     )
-    return conversation
+    return conversation

openhands_cli/tui/tui.py

@@ -8,6 +8,7 @@
 from prompt_toolkit.shortcuts import clear
 
 from openhands_cli.pt_style import get_cli_style
+from openhands_cli.version_check import check_for_updates
 
 
 DEFAULT_STYLE = get_cli_style()
@@ -93,6 +94,23 @@ def display_welcome(conversation_id: UUID, resume: bool = False) -> None:
     """Display welcome message."""
     clear()
     display_banner(str(conversation_id), resume)
+
+    # Check for updates and display version info
+    version_info = check_for_updates()
+    print_formatted_text(HTML(f"<grey>Version: {version_info.current_version}</grey>"))
+
+    if version_info.needs_update and version_info.latest_version:
+        print_formatted_text(
+            HTML(f"<yellow>⚠ Update available: {version_info.latest_version}</yellow>")
+        )
+        print_formatted_text(
+            HTML(
+                "<grey>Run</grey> <gold>uv tool upgrade openhands</gold> "
+                "<grey>to update</grey>"
+            )
+        )
+
+    print_formatted_text("")
     print_formatted_text(HTML("<gold>Let's start building!</gold>"))
     print_formatted_text(
         HTML(

openhands_cli/version_check.py

@@ -0,0 +1,83 @@
+"""Version checking utilities for OpenHands CLI."""
+
+import json
+import urllib.request
+from typing import NamedTuple
+
+from openhands_cli import __version__
+
+
+class VersionInfo(NamedTuple):
+    """Version information for display."""
+
+    current_version: str
+    latest_version: str | None
+    needs_update: bool
+    error: str | None
+
+
+def parse_version(version_str: str) -> tuple[int, ...]:
+    """Parse a version string into a tuple of integers for comparison.
+
+    Args:
+        version_str: Version string like "1.2.1"
+
+    Returns:
+        Tuple of integers like (1, 2, 1)
+    """
+    return tuple(int(x) for x in version_str.split("."))
+
+
+def check_for_updates(timeout: float = 2.0) -> VersionInfo:
+    """Check if a newer version is available on PyPI.
+
+    Args:
+        timeout: Timeout for PyPI request in seconds
+
+    Returns:
+        VersionInfo with update information
+    """
+    current = __version__
+
+    # Handle dev versions or special cases
+    if current == "0.0.0" or "dev" in current:
+        return VersionInfo(
+            current_version=current,
+            latest_version=None,
+            needs_update=False,
+            error=None,
+        )
+
+    try:
+        # Fetch latest version from PyPI
+        url = "https://pypi.org/pypi/openhands/json"
+        req = urllib.request.Request(url)
+        req.add_header("User-Agent", f"openhands-cli/{current}")
+
+        with urllib.request.urlopen(req, timeout=timeout) as response:
+            data = json.loads(response.read().decode("utf-8"))
+            latest = data["info"]["version"]
+
+        # Compare versions
+        try:
+            current_tuple = parse_version(current)
+            latest_tuple = parse_version(latest)
+            needs_update = latest_tuple > current_tuple
+        except (ValueError, AttributeError):
+            # If we can't parse versions, assume no update needed
+            needs_update = False
+
+        return VersionInfo(
+            current_version=current,
+            latest_version=latest,
+            needs_update=needs_update,
+            error=None,
+        )
+    except Exception as e:
+        # Don't block on network errors - just return current version
+        return VersionInfo(
+            current_version=current,
+            latest_version=None,
+            needs_update=False,
+            error=str(e),
+        )

pyproject.toml

@@ -4,7 +4,7 @@ requires = [ "hatchling>=1.25" ]
 
 [project]
 name = "openhands"
-version = "1.2.1"
+version = "1.3.0"
 description = "OpenHands CLI - Terminal User Interface for OpenHands AI Agent"
 readme = "README.md"
 license = { text = "MIT" }