openhands 1.3.0__py3-none-any.whl

openhands_cli/setup.py

@@ -0,0 +1,136 @@
+from typing import Any
+from uuid import UUID
+
+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.sdk.security.confirmation_policy import (
+    AlwaysConfirm,
+)
+from openhands.sdk.security.llm_analyzer import LLMSecurityAnalyzer
+
+# Register tools on import
+from openhands.tools.file_editor import FileEditorTool  # noqa: F401
+from openhands.tools.task_tracker import TaskTrackerTool  # noqa: F401
+from openhands.tools.terminal import TerminalTool  # noqa: F401
+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
+
+
+class MissingAgentSpec(Exception):
+    """Raised when agent specification is not found or invalid."""
+
+    pass
+
+
+def load_agent_specs(
+    conversation_id: str | None = None,
+    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)
+    if not agent:
+        raise MissingAgentSpec(
+            "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() -> Agent:
+    """Verify agent specs exists by attempting to load it."""
+    settings_screen = SettingsScreen()
+    try:
+        agent = load_agent_specs()
+        return agent
+    except MissingAgentSpec:
+        # 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()
+
+
+def setup_conversation(
+    conversation_id: UUID, include_security_analyzer: bool = True
+) -> BaseConversation:
+    """
+    Setup the conversation with agent.
+
+    Args:
+        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("<white>Initializing agent...</white>"))
+
+    agent = load_agent_specs(str(conversation_id))
+
+    # Create conversation - agent context is now set in AgentStore.load()
+    conversation: BaseConversation = Conversation(
+        agent=agent,
+        workspace=Workspace(working_dir=WORK_DIR),
+        # Conversation will add /<conversation_id> to this path
+        persistence_dir=CONVERSATIONS_DIR,
+        conversation_id=conversation_id,
+        visualizer=CLIVisualizer,
+    )
+
+    # Security analyzer is set though conversation API now
+    if not include_security_analyzer:
+        conversation.set_security_analyzer(None)
+    else:
+        conversation.set_security_analyzer(LLMSecurityAnalyzer())
+        conversation.set_confirmation_policy(AlwaysConfirm())
+
+    print_formatted_text(
+        HTML(f"<green>✓ Agent initialized with model: {agent.llm.model}</green>")
+    )
+    return conversation

openhands_cli/simple_main.py

@@ -0,0 +1,71 @@
+#!/usr/bin/env python3
+"""
+Simple main entry point for OpenHands CLI.
+This is a simplified version that demonstrates the TUI functionality.
+"""
+
+import logging
+import os
+import warnings
+
+from prompt_toolkit import print_formatted_text
+from prompt_toolkit.formatted_text import HTML
+
+from openhands_cli.argparsers.main_parser import create_main_parser
+from openhands_cli.utils import create_seeded_instructions_from_args
+
+
+debug_env = os.getenv("DEBUG", "false").lower()
+if debug_env != "1" and debug_env != "true":
+    logging.disable(logging.WARNING)
+    warnings.filterwarnings("ignore")
+
+
+def main() -> None:
+    """Main entry point for the OpenHands CLI.
+
+    Raises:
+        ImportError: If agent chat dependencies are missing
+        Exception: On other error conditions
+    """
+    parser = create_main_parser()
+    args = parser.parse_args()
+
+    try:
+        if args.command == "serve":
+            # Import gui_launcher only when needed
+            from openhands_cli.gui_launcher import launch_gui_server
+
+            launch_gui_server(mount_cwd=args.mount_cwd, gpu=args.gpu)
+        elif args.command == "acp":
+            import asyncio
+
+            from openhands_cli.acp_impl.agent import run_acp_server
+
+            asyncio.run(run_acp_server())
+        else:
+            # Default CLI behavior - no subcommand needed
+            # Import agent_chat only when needed
+            from openhands_cli.agent_chat import run_cli_entry
+
+            queued_inputs = create_seeded_instructions_from_args(args)
+
+            # Start agent chat
+            run_cli_entry(
+                resume_conversation_id=args.resume,
+                queued_inputs=queued_inputs,
+            )
+    except KeyboardInterrupt:
+        print_formatted_text(HTML("\n<yellow>Goodbye! 👋</yellow>"))
+    except EOFError:
+        print_formatted_text(HTML("\n<yellow>Goodbye! 👋</yellow>"))
+    except Exception as e:
+        print_formatted_text(HTML(f"<red>Error: {e}</red>"))
+        import traceback
+
+        traceback.print_exc()
+        raise
+
+
+if __name__ == "__main__":
+    main()

openhands_cli/tui/__init__.py

@@ -0,0 +1,6 @@
+from openhands_cli.tui.tui import DEFAULT_STYLE
+
+
+__all__ = [
+    "DEFAULT_STYLE",
+]

openhands_cli/tui/settings/mcp_screen.py

@@ -0,0 +1,225 @@
+import json
+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
+from openhands_cli.locations import MCP_CONFIG_FILE, PERSISTENCE_DIR
+
+
+class MCPScreen:
+    """
+    MCP Screen
+
+    1. Display information about setting up MCP
+    2. See existing servers that are setup
+    3. Debug additional servers passed via mcp.json
+    4. Identify servers waiting to sync on session restart
+    """
+
+    # ---------- server spec handlers ----------
+
+    def _check_server_specs_are_equal(
+        self, first_server_spec, second_server_spec
+    ) -> bool:
+        first_stringified_server_spec = json.dumps(first_server_spec, sort_keys=True)
+        second_stringified_server_spec = json.dumps(second_server_spec, sort_keys=True)
+        return first_stringified_server_spec == second_stringified_server_spec
+
+    def _check_mcp_config_status(self) -> dict:
+        """Check the status of the MCP configuration file and return information
+        about it."""
+        config_path = Path(PERSISTENCE_DIR) / MCP_CONFIG_FILE
+
+        if not config_path.exists():
+            return {
+                "exists": False,
+                "valid": False,
+                "servers": {},
+                "message": (
+                    f"MCP configuration file not found at "
+                    f"~/.openhands/{MCP_CONFIG_FILE}"
+                ),
+            }
+
+        try:
+            mcp_config = MCPConfig.from_file(config_path)
+            servers = mcp_config.to_dict().get("mcpServers", {})
+            return {
+                "exists": True,
+                "valid": True,
+                "servers": servers,
+                "message": (
+                    f"Valid MCP configuration found with {len(servers)} server(s)"
+                ),
+            }
+        except Exception as e:
+            return {
+                "exists": True,
+                "valid": False,
+                "servers": {},
+                "message": f"Invalid MCP configuration file: {str(e)}",
+            }
+
+    # ---------- TUI helpers ----------
+
+    def _get_mcp_server_diff(
+        self,
+        current: dict[str, Any],
+        incoming: dict[str, Any],
+    ) -> None:
+        """
+        Display a diff-style view:
+
+        - Always show the MCP servers the agent is *currently* configured with
+        - If there are incoming servers (from ~/.openhands/mcp.json),
+          clearly show which ones are NEW (not in current) and which ones are CHANGED
+          (same name but different config). Unchanged servers are not repeated.
+        """
+
+        print_formatted_text(HTML("<white>Current Agent MCP Servers:</white>"))
+        if current:
+            for name, cfg in current.items():
+                self._render_server_summary(name, cfg, indent=2)
+        else:
+            print_formatted_text(
+                HTML("  <yellow>None configured on the current agent.</yellow>")
+            )
+        print_formatted_text("")
+
+        # If no incoming, we're done
+        if not incoming:
+            print_formatted_text(
+                HTML("<grey>No incoming servers detected for next restart.</grey>")
+            )
+            print_formatted_text("")
+            return
+
+        # Compare names and configs
+        current_names = set(current.keys())
+        incoming_names = set(incoming.keys())
+        new_servers = sorted(incoming_names - current_names)
+
+        overriden_servers = []
+        for name in sorted(incoming_names & current_names):
+            if not self._check_server_specs_are_equal(current[name], incoming[name]):
+                overriden_servers.append(name)
+
+        # Display incoming section header
+        print_formatted_text(
+            HTML(
+                "<white>Incoming Servers on Restart "
+                "(from ~/.openhands/mcp.json):</white>"
+            )
+        )
+
+        if not new_servers and not overriden_servers:
+            print_formatted_text(
+                HTML(
+                    "  <grey>All configured servers match the current agent "
+                    "configuration.</grey>"
+                )
+            )
+            print_formatted_text("")
+            return
+
+        if new_servers:
+            print_formatted_text(HTML("  <green>New servers (will be added):</green>"))
+            for name in new_servers:
+                self._render_server_summary(name, incoming[name], indent=4)
+
+        if overriden_servers:
+            print_formatted_text(
+                HTML("  <yellow>Updated servers (configuration will change):</yellow>")
+            )
+            for name in overriden_servers:
+                print_formatted_text(HTML(f"    <white>• {name}</white>"))
+                print_formatted_text(HTML("      <grey>Current:</grey>"))
+                self._render_server_summary(None, current[name], indent=8)
+                print_formatted_text(HTML("      <grey>Incoming:</grey>"))
+                self._render_server_summary(None, incoming[name], indent=8)
+
+        print_formatted_text("")
+
+    def _render_server_summary(
+        self, server_name: str | None, server_spec: dict[str, Any], indent: int = 2
+    ) -> None:
+        pad = " " * indent
+
+        if server_name:
+            print_formatted_text(HTML(f"{pad}<white>• {server_name}</white>"))
+
+        if isinstance(server_spec, dict):
+            if "command" in server_spec:
+                cmd = server_spec.get("command", "")
+                args = server_spec.get("args", [])
+                args_str = " ".join(args) if args else ""
+                print_formatted_text(HTML(f"{pad}  <grey>Type: Command-based</grey>"))
+                if cmd or args_str:
+                    print_formatted_text(
+                        HTML(f"{pad}  <grey>Command: {cmd} {args_str}</grey>")
+                    )
+            elif "url" in server_spec:
+                url = server_spec.get("url", "")
+                auth = server_spec.get("auth", "none")
+                print_formatted_text(HTML(f"{pad}  <grey>Type: URL-based</grey>"))
+                if url:
+                    print_formatted_text(HTML(f"{pad}  <grey>URL: {url}</grey>"))
+                print_formatted_text(HTML(f"{pad}  <grey>Auth: {auth}</grey>"))
+
+    def _display_information_header(self) -> None:
+        print_formatted_text(
+            HTML("<gold>MCP (Model Context Protocol) Configuration</gold>")
+        )
+        print_formatted_text("")
+        print_formatted_text(HTML("<white>To get started:</white>"))
+        print_formatted_text(
+            HTML(
+                "  1. Create the configuration file: <cyan>~/.openhands/mcp.json</cyan>"
+            )
+        )
+        print_formatted_text(
+            HTML(
+                "  2. Add your MCP server configurations "
+                "<cyan>https://gofastmcp.com/clients/client#configuration-format</cyan>"
+            )
+        )
+        print_formatted_text(
+            HTML("  3. Restart your OpenHands session to load the new configuration")
+        )
+        print_formatted_text("")
+
+    # ---------- status + display entrypoint ----------
+
+    def display_mcp_info(self, existing_agent: Agent) -> None:
+        """Display comprehensive MCP configuration information."""
+
+        self._display_information_header()
+
+        # Always determine current & incoming first
+        status = self._check_mcp_config_status()
+        incoming_servers = status.get("servers", {}) if status.get("valid") else {}
+        current_servers = existing_agent.mcp_config.get("mcpServers", {})
+
+        # Show file status
+        if not status["exists"]:
+            print_formatted_text(
+                HTML("<yellow>Status: Configuration file not found</yellow>")
+            )
+
+        elif not status["valid"]:
+            print_formatted_text(HTML(f"<red>Status: {status['message']}</red>"))
+            print_formatted_text("")
+            print_formatted_text(
+                HTML("<white>Please check your configuration file format.</white>")
+            )
+        else:
+            print_formatted_text(HTML(f"<green>Status: {status['message']}</green>"))
+
+        print_formatted_text("")
+
+        # Always show the agent's current servers
+        # Then show incoming (deduped and changes highlighted)
+        self._get_mcp_server_diff(current_servers, incoming_servers)

openhands_cli/tui/settings/settings_screen.py

@@ -0,0 +1,226 @@
+import os
+from typing import Any
+
+from prompt_toolkit import HTML, print_formatted_text
+from prompt_toolkit.shortcuts import print_container
+from prompt_toolkit.widgets import Frame, TextArea
+
+from openhands.sdk import LLM, BaseConversation, LLMSummarizingCondenser, LocalFileStore
+from openhands_cli.locations import AGENT_SETTINGS_PATH, PERSISTENCE_DIR
+from openhands_cli.pt_style import COLOR_GREY
+from openhands_cli.tui.settings.store import AgentStore
+from openhands_cli.tui.utils import StepCounter
+from openhands_cli.user_actions.settings_action import (
+    SettingsType,
+    choose_llm_model,
+    choose_llm_provider,
+    choose_memory_condensation,
+    prompt_api_key,
+    prompt_base_url,
+    prompt_custom_model,
+    save_settings_confirmation,
+    settings_type_confirmation,
+)
+from openhands_cli.utils import (
+    get_default_cli_agent,
+    get_llm_metadata,
+    should_set_litellm_extra_body,
+)
+
+
+class SettingsScreen:
+    def __init__(self, conversation: BaseConversation | None = None):
+        self.file_store = LocalFileStore(PERSISTENCE_DIR)
+        self.agent_store = AgentStore()
+        self.conversation = conversation
+
+    def display_settings(self) -> None:
+        agent_spec = self.agent_store.load()
+        if not agent_spec:
+            return
+
+        llm = agent_spec.llm
+        advanced_llm_settings = True if llm.base_url else False
+
+        # Prepare labels and values based on settings
+        labels_and_values = []
+        if not advanced_llm_settings:
+            # Attempt to determine provider, fallback if not directly available
+            provider = llm.model.split("/")[0] if "/" in llm.model else "Unknown"
+
+            labels_and_values.extend(
+                [
+                    ("   LLM Provider", str(provider)),
+                    ("   LLM Model", str(llm.model)),
+                ]
+            )
+        else:
+            labels_and_values.extend(
+                [
+                    ("   Custom Model", llm.model),
+                    ("   Base URL", llm.base_url),
+                ]
+            )
+        labels_and_values.extend(
+            [
+                ("   API Key", "********" if llm.api_key else "Not Set"),
+            ]
+        )
+
+        if self.conversation:
+            labels_and_values.extend(
+                [
+                    (
+                        "   Confirmation Mode",
+                        "Enabled"
+                        if self.conversation.is_confirmation_mode_active
+                        else "Disabled",
+                    )
+                ]
+            )
+
+        labels_and_values.extend(
+            [
+                (
+                    "   Memory Condensation",
+                    "Enabled" if agent_spec.condenser else "Disabled",
+                ),
+                (
+                    "   Configuration File",
+                    os.path.join(PERSISTENCE_DIR, AGENT_SETTINGS_PATH),
+                ),
+            ]
+        )
+
+        # Calculate max widths for alignment
+        # Ensure values are strings for len() calculation
+        str_labels_and_values = [
+            (label, str(value)) for label, value in labels_and_values
+        ]
+        max_label_width = (
+            max(len(label) for label, _ in str_labels_and_values)
+            if str_labels_and_values
+            else 0
+        )
+
+        # Construct the summary text with aligned columns
+        settings_lines = [
+            f"{label + ':':<{max_label_width + 1}} {value:<}"  # Changed value
+            # alignment to left (<)
+            for label, value in str_labels_and_values
+        ]
+        settings_text = "\n".join(settings_lines)
+
+        container = Frame(
+            TextArea(
+                text=settings_text,
+                read_only=True,
+                style=COLOR_GREY,
+                wrap_lines=True,
+            ),
+            title="Settings",
+            style=f"fg:{COLOR_GREY}",
+        )
+
+        print_container(container)
+
+        self.configure_settings()
+
+    def configure_settings(self, first_time=False):
+        try:
+            settings_type = settings_type_confirmation(first_time=first_time)
+        except KeyboardInterrupt:
+            return
+
+        if settings_type == SettingsType.BASIC:
+            self.handle_basic_settings()
+        elif settings_type == SettingsType.ADVANCED:
+            self.handle_advanced_settings()
+
+    def handle_basic_settings(self):
+        step_counter = StepCounter(3)
+        try:
+            provider = choose_llm_provider(step_counter, escapable=True)
+            llm_model = choose_llm_model(step_counter, provider, escapable=True)
+            api_key = prompt_api_key(
+                step_counter,
+                provider,
+                self.conversation.state.agent.llm.api_key
+                if self.conversation
+                else None,
+                escapable=True,
+            )
+            save_settings_confirmation()
+        except KeyboardInterrupt:
+            print_formatted_text(HTML("\n<red>Cancelled settings change.</red>"))
+            return
+
+        # Store the collected settings for persistence
+        self._save_llm_settings(f"{provider}/{llm_model}", api_key)
+
+    def handle_advanced_settings(self, escapable=True):
+        """Handle advanced settings configuration with clean step-by-step flow."""
+        step_counter = StepCounter(4)
+        try:
+            custom_model = prompt_custom_model(step_counter)
+            base_url = prompt_base_url(step_counter)
+            api_key = prompt_api_key(
+                step_counter,
+                custom_model.split("/")[0] if len(custom_model.split("/")) > 1 else "",
+                self.conversation.state.agent.llm.api_key
+                if self.conversation
+                else None,
+                escapable=escapable,
+            )
+            memory_condensation = choose_memory_condensation(step_counter)
+
+            # Confirm save
+            save_settings_confirmation()
+        except KeyboardInterrupt:
+            print_formatted_text(HTML("\n<red>Cancelled settings change.</red>"))
+            return
+
+        # Store the collected settings for persistence
+        self._save_advanced_settings(
+            custom_model, base_url, api_key, memory_condensation
+        )
+
+    def _save_llm_settings(self, model, api_key, base_url: str | None = None) -> None:
+        extra_kwargs: dict[str, Any] = {}
+        if should_set_litellm_extra_body(model):
+            extra_kwargs["litellm_extra_body"] = {
+                "metadata": get_llm_metadata(model_name=model, llm_type="agent")
+            }
+        llm = LLM(
+            model=model,
+            api_key=api_key,
+            base_url=base_url,
+            usage_id="agent",
+            **extra_kwargs,
+        )
+
+        agent = self.agent_store.load()
+        if not agent:
+            agent = get_default_cli_agent(llm=llm)
+
+        # Must update all LLMs
+        agent = agent.model_copy(update={"llm": llm})
+        condenser = LLMSummarizingCondenser(
+            llm=llm.model_copy(update={"usage_id": "condenser"})
+        )
+        agent = agent.model_copy(update={"condenser": condenser})
+        self.agent_store.save(agent)
+
+    def _save_advanced_settings(
+        self, custom_model: str, base_url: str, api_key: str, memory_condensation: bool
+    ):
+        self._save_llm_settings(custom_model, api_key, base_url=base_url)
+
+        agent_spec = self.agent_store.load()
+        if not agent_spec:
+            return
+
+        if not memory_condensation:
+            agent_spec.model_copy(update={"condenser": None})
+
+        self.agent_store.save(agent_spec)