openhands 1.3.0__py3-none-any.whl

openhands_cli/tui/settings/store.py

@@ -0,0 +1,132 @@
+# openhands_cli/settings/store.py
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from fastmcp.mcp_config import MCPConfig
+from prompt_toolkit import HTML, print_formatted_text
+
+from openhands.sdk import Agent, AgentContext, LocalFileStore
+from openhands.sdk.context import load_skills_from_dir
+from openhands.sdk.context.condenser import LLMSummarizingCondenser
+from openhands.tools.preset.default import get_default_tools
+from openhands_cli.locations import (
+    AGENT_SETTINGS_PATH,
+    MCP_CONFIG_FILE,
+    PERSISTENCE_DIR,
+    WORK_DIR,
+)
+from openhands_cli.utils import get_llm_metadata, should_set_litellm_extra_body
+
+
+class AgentStore:
+    """Single source of truth for persisting/retrieving AgentSpec."""
+
+    def __init__(self) -> None:
+        self.file_store = LocalFileStore(root=PERSISTENCE_DIR)
+
+    def load_mcp_configuration(self) -> dict[str, Any]:
+        try:
+            mcp_config_path = Path(self.file_store.root) / MCP_CONFIG_FILE
+            mcp_config = MCPConfig.from_file(mcp_config_path)
+            return mcp_config.to_dict()["mcpServers"]
+        except Exception:
+            return {}
+
+    def load_project_skills(self) -> list:
+        """Load skills project-specific directories."""
+        all_skills = []
+
+        # Load project-specific skills from .openhands/skills and legacy microagents
+        project_skills_dirs = [
+            Path(WORK_DIR) / ".openhands" / "skills",
+            Path(WORK_DIR) / ".openhands" / "microagents",  # Legacy support
+        ]
+
+        for project_skills_dir in project_skills_dirs:
+            if project_skills_dir.exists():
+                try:
+                    repo_skills, knowledge_skills = load_skills_from_dir(
+                        project_skills_dir
+                    )
+                    project_skills = list(repo_skills.values()) + list(
+                        knowledge_skills.values()
+                    )
+                    all_skills.extend(project_skills)
+                except Exception:
+                    pass
+
+        return all_skills
+
+    def load(self, session_id: str | None = None) -> Agent | None:
+        try:
+            str_spec = self.file_store.read(AGENT_SETTINGS_PATH)
+            agent = Agent.model_validate_json(str_spec)
+
+            # Update tools with most recent working directory
+            updated_tools = get_default_tools(enable_browser=False)
+
+            # Load skills from user directories and project-specific directories
+            skills = self.load_project_skills()
+
+            agent_context = AgentContext(
+                skills=skills,
+                system_message_suffix=f"You current working directory is: {WORK_DIR}",
+                load_user_skills=True,
+            )
+
+            mcp_config: dict = self.load_mcp_configuration()
+
+            # Update LLM metadata with current information
+            llm_update = {}
+            if should_set_litellm_extra_body(agent.llm.model):
+                llm_update["litellm_extra_body"] = {
+                    "metadata": get_llm_metadata(
+                        model_name=agent.llm.model,
+                        llm_type="agent",
+                        session_id=session_id,
+                    )
+                }
+            updated_llm = agent.llm.model_copy(update=llm_update)
+
+            condenser_updates = {}
+            if agent.condenser and isinstance(agent.condenser, LLMSummarizingCondenser):
+                condenser_llm_update = {}
+                if should_set_litellm_extra_body(agent.condenser.llm.model):
+                    condenser_llm_update["litellm_extra_body"] = {
+                        "metadata": get_llm_metadata(
+                            model_name=agent.condenser.llm.model,
+                            llm_type="condenser",
+                            session_id=session_id,
+                        )
+                    }
+                condenser_updates["llm"] = agent.condenser.llm.model_copy(
+                    update=condenser_llm_update
+                )
+
+            # Update tools and context
+            agent = agent.model_copy(
+                update={
+                    "llm": updated_llm,
+                    "tools": updated_tools,
+                    "mcp_config": {"mcpServers": mcp_config} if mcp_config else {},
+                    "agent_context": agent_context,
+                    "condenser": agent.condenser.model_copy(update=condenser_updates)
+                    if agent.condenser
+                    else None,
+                }
+            )
+
+            return agent
+        except FileNotFoundError:
+            return None
+        except Exception:
+            print_formatted_text(
+                HTML("\n<red>Agent configuration file is corrupted!</red>")
+            )
+            return None
+
+    def save(self, agent: Agent) -> None:
+        serialized_spec = agent.model_dump_json(context={"expose_secrets": True})
+        self.file_store.write(AGENT_SETTINGS_PATH, serialized_spec)

openhands_cli/tui/status.py

@@ -0,0 +1,110 @@
+"""Status display components for OpenHands CLI TUI."""
+
+from datetime import datetime
+
+from prompt_toolkit import print_formatted_text
+from prompt_toolkit.formatted_text import HTML
+from prompt_toolkit.shortcuts import print_container
+from prompt_toolkit.widgets import Frame, TextArea
+
+from openhands.sdk import BaseConversation
+
+
+def display_status(
+    conversation: BaseConversation,
+    session_start_time: datetime,
+) -> None:
+    """Display detailed conversation status including metrics and uptime.
+
+    Args:
+        conversation: The conversation to display status for
+        session_start_time: The session start time for uptime calculation
+    """
+    # Get conversation stats
+    stats = conversation.conversation_stats.get_combined_metrics()
+
+    # Calculate uptime from session start time
+    now = datetime.now()
+    diff = now - session_start_time
+
+    # Format as hours, minutes, seconds
+    total_seconds = int(diff.total_seconds())
+    hours = total_seconds // 3600
+    minutes = (total_seconds % 3600) // 60
+    seconds = total_seconds % 60
+    uptime_str = f"{hours}h {minutes}m {seconds}s"
+
+    # Display conversation ID and uptime
+    print_formatted_text(HTML(f"<grey>Conversation ID: {conversation.id}</grey>"))
+    print_formatted_text(HTML(f"<grey>Uptime:          {uptime_str}</grey>"))
+    print_formatted_text("")
+
+    # Calculate token metrics
+    token_usage = stats.accumulated_token_usage
+    total_input_tokens = token_usage.prompt_tokens if token_usage else 0
+    total_output_tokens = token_usage.completion_tokens if token_usage else 0
+    cache_hits = token_usage.cache_read_tokens if token_usage else 0
+    cache_writes = token_usage.cache_write_tokens if token_usage else 0
+    total_tokens = total_input_tokens + total_output_tokens
+    total_cost = stats.accumulated_cost
+
+    # Use prompt_toolkit containers for formatted display
+    _display_usage_metrics_container(
+        total_cost,
+        total_input_tokens,
+        total_output_tokens,
+        cache_hits,
+        cache_writes,
+        total_tokens,
+    )
+
+
+def _display_usage_metrics_container(
+    total_cost: float,
+    total_input_tokens: int,
+    total_output_tokens: int,
+    cache_hits: int,
+    cache_writes: int,
+    total_tokens: int,
+) -> None:
+    """Display usage metrics using prompt_toolkit containers."""
+    # Format values with proper formatting
+    cost_str = f"${total_cost:.6f}"
+    input_tokens_str = f"{total_input_tokens:,}"
+    cache_read_str = f"{cache_hits:,}"
+    cache_write_str = f"{cache_writes:,}"
+    output_tokens_str = f"{total_output_tokens:,}"
+    total_tokens_str = f"{total_tokens:,}"
+
+    labels_and_values = [
+        ("   Total Cost (USD):", cost_str),
+        ("", ""),
+        ("   Total Input Tokens:", input_tokens_str),
+        ("      Cache Hits:", cache_read_str),
+        ("      Cache Writes:", cache_write_str),
+        ("   Total Output Tokens:", output_tokens_str),
+        ("", ""),
+        ("   Total Tokens:", total_tokens_str),
+    ]
+
+    # Calculate max widths for alignment
+    max_label_width = max(len(label) for label, _ in labels_and_values)
+    max_value_width = max(len(value) for _, value in labels_and_values)
+
+    # Construct the summary text with aligned columns
+    summary_lines = [
+        f"{label:<{max_label_width}} {value:<{max_value_width}}"
+        for label, value in labels_and_values
+    ]
+    summary_text = "\n".join(summary_lines)
+
+    container = Frame(
+        TextArea(
+            text=summary_text,
+            read_only=True,
+            wrap_lines=True,
+        ),
+        title="Usage Metrics",
+    )
+
+    print_container(container)

openhands_cli/tui/tui.py

@@ -0,0 +1,120 @@
+from collections.abc import Generator
+from uuid import UUID
+
+from prompt_toolkit import print_formatted_text
+from prompt_toolkit.completion import CompleteEvent, Completer, Completion
+from prompt_toolkit.document import Document
+from prompt_toolkit.formatted_text import HTML
+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()
+
+# Available commands with descriptions
+COMMANDS = {
+    "/exit": "Exit the application",
+    "/help": "Display available commands",
+    "/clear": "Clear the screen",
+    "/new": "Start a fresh conversation",
+    "/status": "Display conversation details",
+    "/confirm": "Toggle confirmation mode on/off",
+    "/resume": "Resume a paused conversation",
+    "/settings": "Display and modify current settings",
+    "/mcp": "View MCP (Model Context Protocol) server configuration",
+}
+
+
+class CommandCompleter(Completer):
+    """Custom completer for commands with interactive dropdown."""
+
+    def get_completions(
+        self,
+        document: Document,
+        complete_event: CompleteEvent,  # noqa: ARG002
+    ) -> Generator[Completion, None, None]:
+        text = document.text_before_cursor.lstrip()
+        if text.startswith("/"):
+            for command, description in COMMANDS.items():
+                if command.startswith(text):
+                    yield Completion(
+                        command,
+                        start_position=-len(text),
+                        display_meta=description,
+                        style="bg:ansidarkgray fg:gold",
+                    )
+
+
+def display_banner(conversation_id: str, resume: bool = False) -> None:
+    print_formatted_text(
+        HTML(r"""<gold>
+     ___                    _   _                 _
+    /  _ \ _ __   ___ _ __ | | | | __ _ _ __   __| |___
+    | | | | '_ \ / _ \ '_ \| |_| |/ _` | '_ \ / _` / __|
+    | |_| | |_) |  __/ | | |  _  | (_| | | | | (_| \__ \
+    \___ /| .__/ \___|_| |_|_| |_|\__,_|_| |_|\__,_|___/
+          |_|
+    </gold>"""),
+        style=DEFAULT_STYLE,
+    )
+
+    print_formatted_text("")
+    if not resume:
+        print_formatted_text(
+            HTML(f"<grey>Initialized conversation {conversation_id}</grey>")
+        )
+    else:
+        print_formatted_text(
+            HTML(f"<grey>Resumed conversation {conversation_id}</grey>")
+        )
+    print_formatted_text("")
+
+
+def display_help() -> None:
+    """Display help information about available commands."""
+    print_formatted_text("")
+    print_formatted_text(HTML("<gold>🤖 OpenHands CLI Help</gold>"))
+    print_formatted_text(HTML("<grey>Available commands:</grey>"))
+    print_formatted_text("")
+
+    for command, description in COMMANDS.items():
+        print_formatted_text(HTML(f"  <white>{command}</white> - {description}"))
+
+    print_formatted_text("")
+    print_formatted_text(HTML("<grey>Tips:</grey>"))
+    print_formatted_text("  • Type / and press Tab to see command suggestions")
+    print_formatted_text("  • Use arrow keys to navigate through suggestions")
+    print_formatted_text("  • Press Enter to select a command")
+    print_formatted_text("")
+
+
+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(
+            "<green>What do you want to build? <grey>Type /help for help</grey></green>"
+        )
+    )
+    print()

openhands_cli/tui/utils.py

@@ -0,0 +1,14 @@
+class StepCounter:
+    """Automatically manages step numbering for settings flows."""
+
+    def __init__(self, total_steps: int):
+        self.current_step = 0
+        self.total_steps = total_steps
+
+    def next_step(self, prompt: str) -> str:
+        """Get the next step prompt with automatic numbering."""
+        self.current_step += 1
+        return f"(Step {self.current_step}/{self.total_steps}) {prompt}"
+
+    def existing_step(self, prompt: str) -> str:
+        return f"(Step {self.current_step}/{self.total_steps}) {prompt}"

openhands_cli/tui/visualizer.py

@@ -0,0 +1,22 @@
+"""CLI-specific visualization configuration.
+
+This module customizes the SDK's default visualizer for CLI usage by:
+- Skipping SystemPromptEvent (only relevant for SDK internals)
+- Re-exporting DefaultConversationVisualizer for use in CLI
+"""
+
+from openhands.sdk.conversation.visualizer.default import (
+    EVENT_VISUALIZATION_CONFIG,
+    DefaultConversationVisualizer as CLIVisualizer,
+    EventVisualizationConfig,
+)
+from openhands.sdk.event import SystemPromptEvent
+
+
+# CLI-specific customization: skip SystemPromptEvent
+# (not needed in CLI output, only relevant for SDK internals)
+EVENT_VISUALIZATION_CONFIG[SystemPromptEvent] = EventVisualizationConfig(
+    **{**EVENT_VISUALIZATION_CONFIG[SystemPromptEvent].model_dump(), "skip": True}
+)
+
+__all__ = ["CLIVisualizer"]

openhands_cli/user_actions/__init__.py

@@ -0,0 +1,18 @@
+from openhands_cli.user_actions.agent_action import ask_user_confirmation
+from openhands_cli.user_actions.exit_session import (
+    exit_session_confirmation,
+)
+from openhands_cli.user_actions.settings_action import (
+    choose_llm_provider,
+    settings_type_confirmation,
+)
+from openhands_cli.user_actions.types import UserConfirmation
+
+
+__all__ = [
+    "ask_user_confirmation",
+    "exit_session_confirmation",
+    "UserConfirmation",
+    "settings_type_confirmation",
+    "choose_llm_provider",
+]

openhands_cli/user_actions/agent_action.py

@@ -0,0 +1,82 @@
+import html
+
+from prompt_toolkit import HTML, print_formatted_text
+
+from openhands.sdk.security.confirmation_policy import (
+    ConfirmRisky,
+    NeverConfirm,
+)
+from openhands.sdk.security.risk import SecurityRisk
+from openhands_cli.user_actions.types import ConfirmationResult, UserConfirmation
+from openhands_cli.user_actions.utils import cli_confirm, cli_text_input
+
+
+def ask_user_confirmation(
+    pending_actions: list, using_risk_based_policy: bool = False
+) -> ConfirmationResult:
+    """Ask user to confirm pending actions.
+
+    Args:
+        pending_actions: List of pending actions from the agent
+
+    Returns:
+        ConfirmationResult with decision, optional policy_change, and reason
+    """
+
+    if not pending_actions:
+        return ConfirmationResult(decision=UserConfirmation.ACCEPT)
+
+    print_formatted_text(
+        HTML(
+            f"<yellow>🔍 Agent created {len(pending_actions)} action(s) and is "
+            f"waiting for confirmation:</yellow>"
+        )
+    )
+
+    for i, action in enumerate(pending_actions, 1):
+        tool_name = getattr(action, "tool_name", "[unknown tool]")
+        action_content = (
+            str(getattr(action, "action", ""))[:100].replace("\n", " ")
+            or "[unknown action]"
+        )
+        print_formatted_text(
+            HTML(f"<grey>  {i}. {tool_name}: {html.escape(action_content)}...</grey>")
+        )
+
+    question = "Choose an option:"
+    options = [
+        "Yes, proceed",
+        "Reject",
+        "Always proceed (don't ask again)",
+    ]
+
+    if not using_risk_based_policy:
+        options.append("Auto-confirm LOW/MEDIUM risk, ask for HIGH risk")
+
+    try:
+        index = cli_confirm(question, options, escapable=True)
+    except (EOFError, KeyboardInterrupt):
+        print_formatted_text(HTML("\n<red>No input received; pausing agent.</red>"))
+        return ConfirmationResult(decision=UserConfirmation.DEFER)
+
+    if index == 0:
+        return ConfirmationResult(decision=UserConfirmation.ACCEPT)
+    elif index == 1:
+        # Handle "Reject" option with optional reason
+        try:
+            reason = cli_text_input("Reason (and let OpenHands know why): ").strip()
+        except (EOFError, KeyboardInterrupt):
+            return ConfirmationResult(decision=UserConfirmation.DEFER)
+
+        return ConfirmationResult(decision=UserConfirmation.REJECT, reason=reason)
+    elif index == 2:
+        return ConfirmationResult(
+            decision=UserConfirmation.ACCEPT, policy_change=NeverConfirm()
+        )
+    elif index == 3:
+        return ConfirmationResult(
+            decision=UserConfirmation.ACCEPT,
+            policy_change=ConfirmRisky(threshold=SecurityRisk.HIGH),
+        )
+
+    return ConfirmationResult(decision=UserConfirmation.REJECT)

openhands_cli/user_actions/exit_session.py

@@ -0,0 +1,18 @@
+from openhands_cli.user_actions.types import UserConfirmation
+from openhands_cli.user_actions.utils import cli_confirm
+
+
+def exit_session_confirmation() -> UserConfirmation:
+    """
+    Ask user to confirm exiting session.
+    """
+
+    question = "Terminate session?"
+    options = ["Yes, proceed", "No, dismiss"]
+    index = cli_confirm(question, options)  # Blocking UI, not escapable
+
+    options_mapping = {
+        0: UserConfirmation.ACCEPT,  # User accepts termination session
+        1: UserConfirmation.REJECT,  # User does not terminate session
+    }
+    return options_mapping.get(index, UserConfirmation.REJECT)