openhands 0.0.0__py3-none-any.whl → 1.0.1__py3-none-any.whl

openhands_cli/tui/settings/mcp_screen.py

@@ -0,0 +1,217 @@
+import json
+from pathlib import Path
+from typing import Any
+
+from fastmcp.mcp_config import MCPConfig
+from openhands_cli.locations import MCP_CONFIG_FILE, PERSISTENCE_DIR
+from prompt_toolkit import HTML, print_formatted_text
+
+from openhands.sdk import Agent
+
+
+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 ~/.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,202 @@
+import os
+
+from openhands.sdk import LLM, BaseConversation, LocalFileStore
+from openhands.sdk.security.confirmation_policy import NeverConfirm
+from openhands.tools.preset.default import get_default_agent
+from prompt_toolkit import HTML, print_formatted_text
+from prompt_toolkit.shortcuts import print_container
+from prompt_toolkit.widgets import Frame, TextArea
+
+from openhands_cli.llm_utils import get_llm_metadata
+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,
+)
+
+
+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
+        assert self.conversation is not None, (
+            'Conversation must be set to display settings.'
+        )
+
+        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'),
+                (
+                    '   Confirmation Mode',
+                    'Enabled'
+                    if self.conversation.is_confirmation_mode_active
+                    else 'Disabled',
+                ),
+                (
+                    '   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.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:
+        llm = LLM(
+            model=model,
+            api_key=api_key,
+            base_url=base_url,
+            service_id='agent',
+            metadata=get_llm_metadata(model_name=model, llm_type='agent'),
+        )
+
+        agent = self.agent_store.load()
+        if not agent:
+            agent = get_default_agent(llm=llm, cli_mode=True)
+
+        agent = agent.model_copy(update={'llm': llm})
+        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)

openhands_cli/tui/settings/store.py

@@ -0,0 +1,93 @@
+# openhands_cli/settings/store.py
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from fastmcp.mcp_config import MCPConfig
+from openhands_cli.llm_utils import get_llm_metadata
+from openhands_cli.locations import (
+    AGENT_SETTINGS_PATH,
+    MCP_CONFIG_FILE,
+    PERSISTENCE_DIR,
+    WORK_DIR,
+)
+from prompt_toolkit import HTML, print_formatted_text
+
+from openhands.sdk import Agent, AgentContext, LocalFileStore
+from openhands.sdk.context.condenser import LLMSummarizingCondenser
+from openhands.tools.preset.default import get_default_tools
+
+
+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(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)
+
+            agent_context = AgentContext(
+                system_message_suffix=f'You current working directory is: {WORK_DIR}',
+            )
+
+            additional_mcp_config = self.load_mcp_configuration()
+            mcp_config: dict = agent.mcp_config.copy().get('mcpServers', {})
+            mcp_config.update(additional_mcp_config)
+
+            # Update LLM metadata with current information
+            agent_llm_metadata = get_llm_metadata(
+                model_name=agent.llm.model, llm_type='agent', session_id=session_id
+            )
+            updated_llm = agent.llm.model_copy(update={'metadata': agent_llm_metadata})
+
+            condenser_updates = {}
+            if agent.condenser and isinstance(agent.condenser, LLMSummarizingCondenser):
+                condenser_updates['llm'] = agent.condenser.llm.model_copy(
+                    update={
+                        'metadata': get_llm_metadata(
+                            model_name=agent.condenser.llm.model,
+                            llm_type='condenser',
+                            session_id=session_id,
+                        )
+                    }
+                )
+
+            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,109 @@
+"""Status display components for OpenHands CLI TUI."""
+
+from datetime import datetime
+
+from openhands.sdk import BaseConversation
+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
+
+
+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)