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

openhands_cli/listeners/pause_listener.py

@@ -0,0 +1,83 @@
+import threading
+from collections.abc import Callable, Iterator
+from contextlib import contextmanager
+
+from prompt_toolkit import HTML, print_formatted_text
+from prompt_toolkit.input import Input, create_input
+from prompt_toolkit.keys import Keys
+
+from openhands.sdk import BaseConversation
+
+
+class PauseListener(threading.Thread):
+    """Background key listener that triggers pause on Ctrl-P.
+
+    Starts and stops around agent run() loops to avoid interfering with user prompts.
+    """
+
+    def __init__(
+        self,
+        on_pause: Callable,
+        input_source: Input | None = None,  # used to pipe inputs for unit tests
+    ):
+        super().__init__(daemon=True)
+        self.on_pause = on_pause
+        self._stop_event = threading.Event()
+        self._pause_event = threading.Event()
+        self._input = input_source or create_input()
+
+    def _detect_pause_key_presses(self) -> bool:
+        pause_detected = False
+
+        for key_press in self._input.read_keys():
+            pause_detected = pause_detected or key_press.key == Keys.ControlP
+            pause_detected = pause_detected or key_press.key == Keys.ControlC
+            pause_detected = pause_detected or key_press.key == Keys.ControlD
+
+        return pause_detected
+
+    def _execute_pause(self) -> None:
+        self._pause_event.set()  # Mark pause event occurred
+        print_formatted_text(HTML(''))
+        print_formatted_text(
+            HTML('<gold>Pausing agent once step is completed...</gold>')
+        )
+        try:
+            self.on_pause()
+        except Exception:
+            pass
+
+    def run(self) -> None:
+        try:
+            with self._input.raw_mode():
+                # User hasn't paused and pause listener hasn't been shut down
+                while not (self.is_paused() or self.is_stopped()):
+                    if self._detect_pause_key_presses():
+                        self._execute_pause()
+        finally:
+            try:
+                self._input.close()
+            except Exception:
+                pass
+
+    def stop(self) -> None:
+        self._stop_event.set()
+
+    def is_stopped(self) -> bool:
+        return self._stop_event.is_set()
+
+    def is_paused(self) -> bool:
+        return self._pause_event.is_set()
+
+
+@contextmanager
+def pause_listener(
+    conversation: BaseConversation, input_source: Input | None = None
+) -> Iterator[PauseListener]:
+    """Ensure PauseListener always starts/stops cleanly."""
+    listener = PauseListener(on_pause=conversation.pause, input_source=input_source)
+    listener.start()
+    try:
+        yield listener
+    finally:
+        listener.stop()

openhands_cli/llm_utils.py

@@ -0,0 +1,57 @@
+"""Utility functions for LLM configuration in OpenHands CLI."""
+
+import os
+from typing import Any
+
+
+def get_llm_metadata(
+    model_name: str,
+    llm_type: str,
+    session_id: str | None = None,
+    user_id: str | None = None,
+) -> dict[str, Any]:
+    """
+    Generate LLM metadata for OpenHands CLI.
+
+    Args:
+        model_name: Name of the LLM model
+        agent_name: Name of the agent (defaults to "openhands")
+        session_id: Optional session identifier
+        user_id: Optional user identifier
+
+    Returns:
+        Dictionary containing metadata for LLM initialization
+    """
+    # Import here to avoid circular imports
+    openhands_sdk_version: str = 'n/a'
+    try:
+        import openhands.sdk
+
+        openhands_sdk_version = openhands.sdk.__version__
+    except (ModuleNotFoundError, AttributeError):
+        pass
+
+    openhands_tools_version: str = 'n/a'
+    try:
+        import openhands.tools
+
+        openhands_tools_version = openhands.tools.__version__
+    except (ModuleNotFoundError, AttributeError):
+        pass
+
+    metadata = {
+        'trace_version': openhands_sdk_version,
+        'tags': [
+            'app:openhands',
+            f'model:{model_name}',
+            f'type:{llm_type}',
+            f'web_host:{os.environ.get("WEB_HOST", "unspecified")}',
+            f'openhands_sdk_version:{openhands_sdk_version}',
+            f'openhands_tools_version:{openhands_tools_version}',
+        ],
+    }
+    if session_id is not None:
+        metadata['session_id'] = session_id
+    if user_id is not None:
+        metadata['trace_user_id'] = user_id
+    return metadata

openhands_cli/locations.py

@@ -0,0 +1,13 @@
+import os
+
+# Configuration directory for storing agent settings and CLI configuration
+PERSISTENCE_DIR = os.path.expanduser('~/.openhands')
+CONVERSATIONS_DIR = os.path.join(PERSISTENCE_DIR, 'conversations')
+
+# Working directory for agent operations (current directory where CLI is run)
+WORK_DIR = os.getcwd()
+
+AGENT_SETTINGS_PATH = 'agent_settings.json'
+
+# MCP configuration file (relative to PERSISTENCE_DIR)
+MCP_CONFIG_FILE = 'mcp.json'

openhands_cli/pt_style.py

@@ -0,0 +1,30 @@
+from prompt_toolkit.styles import Style, merge_styles
+from prompt_toolkit.styles.base import BaseStyle
+from prompt_toolkit.styles.defaults import default_ui_style
+
+# Centralized helper for CLI styles so we can safely merge our custom colors
+# with prompt_toolkit's default UI style. This preserves completion menu and
+# fuzzy-match visibility across different terminal themes (e.g., Ubuntu).
+
+COLOR_GOLD = '#FFD700'
+COLOR_GREY = '#808080'
+COLOR_AGENT_BLUE = '#4682B4'  # Steel blue - readable on light/dark backgrounds
+
+
+def get_cli_style() -> BaseStyle:
+    base = default_ui_style()
+    custom = Style.from_dict(
+        {
+            'gold': COLOR_GOLD,
+            'grey': COLOR_GREY,
+            'prompt': f'{COLOR_GOLD} bold',
+            # Ensure good contrast for fuzzy matches on the selected completion row
+            # across terminals/themes (e.g., Ubuntu GNOME, Alacritty, Kitty).
+            # See https://github.com/All-Hands-AI/OpenHands/issues/10330
+            'completion-menu.completion.current fuzzymatch.outside': 'fg:#ffffff bg:#888888',
+            'selected': COLOR_GOLD,
+            'risk-high': '#FF0000 bold',  # Red bold for HIGH risk
+            'placeholder': '#888888 italic',
+        }
+    )
+    return merge_styles([base, custom])

openhands_cli/runner.py

@@ -0,0 +1,178 @@
+from prompt_toolkit import HTML, print_formatted_text
+
+from openhands.sdk import BaseConversation, Message
+from openhands.sdk.conversation.state import AgentExecutionStatus, ConversationState
+from openhands.sdk.security.confirmation_policy import (
+    AlwaysConfirm,
+    ConfirmationPolicyBase,
+    ConfirmRisky,
+    NeverConfirm,
+)
+from openhands_cli.listeners.pause_listener import PauseListener, pause_listener
+from openhands_cli.user_actions import ask_user_confirmation
+from openhands_cli.user_actions.types import UserConfirmation
+from openhands_cli.setup import setup_conversation
+
+
+class ConversationRunner:
+    """Handles the conversation state machine logic cleanly."""
+
+    def __init__(self, conversation: BaseConversation):
+        self.conversation = conversation
+
+    @property
+    def is_confirmation_mode_active(self):
+        return self.conversation.is_confirmation_mode_active
+
+    def toggle_confirmation_mode(self):
+        new_confirmation_mode_state = not self.is_confirmation_mode_active
+
+        self.conversation = setup_conversation(
+            self.conversation.id,
+            include_security_analyzer=new_confirmation_mode_state
+        )
+
+        if new_confirmation_mode_state:
+            # Enable confirmation mode: set AlwaysConfirm policy
+            self.set_confirmation_policy(AlwaysConfirm())
+        else:
+            # Disable confirmation mode: set NeverConfirm policy and remove security analyzer
+            self.set_confirmation_policy(NeverConfirm())
+
+    def set_confirmation_policy(
+        self, confirmation_policy: ConfirmationPolicyBase
+    ) -> None:
+        self.conversation.set_confirmation_policy(confirmation_policy)
+
+
+    def _start_listener(self) -> None:
+        self.listener = PauseListener(on_pause=self.conversation.pause)
+        self.listener.start()
+
+    def _print_run_status(self) -> None:
+        print_formatted_text('')
+        if self.conversation.state.agent_status == AgentExecutionStatus.PAUSED:
+            print_formatted_text(
+                HTML(
+                    '<yellow>Resuming paused conversation...</yellow><grey> (Press Ctrl-P to pause)</grey>'
+                )
+            )
+
+        else:
+            print_formatted_text(
+                HTML(
+                    '<yellow>Agent running...</yellow><grey> (Press Ctrl-P to pause)</grey>'
+                )
+            )
+        print_formatted_text('')
+
+    def process_message(self, message: Message | None) -> None:
+        """Process a user message through the conversation.
+
+        Args:
+            message: The user message to process
+        """
+
+        self._print_run_status()
+
+        # Send message to conversation
+        if message:
+            self.conversation.send_message(message)
+
+        if self.is_confirmation_mode_active:
+            self._run_with_confirmation()
+        else:
+            self._run_without_confirmation()
+
+    def _run_without_confirmation(self) -> None:
+        with pause_listener(self.conversation):
+            self.conversation.run()
+
+    def _run_with_confirmation(self) -> None:
+        # If agent was paused, resume with confirmation request
+        if (
+            self.conversation.state.agent_status
+            == AgentExecutionStatus.WAITING_FOR_CONFIRMATION
+        ):
+            user_confirmation = self._handle_confirmation_request()
+            if user_confirmation == UserConfirmation.DEFER:
+                return
+
+        while True:
+            with pause_listener(self.conversation) as listener:
+                self.conversation.run()
+
+                if listener.is_paused():
+                    break
+
+            # In confirmation mode, agent either finishes or waits for user confirmation
+            if self.conversation.state.agent_status == AgentExecutionStatus.FINISHED:
+                break
+
+            elif (
+                self.conversation.state.agent_status
+                == AgentExecutionStatus.WAITING_FOR_CONFIRMATION
+            ):
+                user_confirmation = self._handle_confirmation_request()
+                if user_confirmation == UserConfirmation.DEFER:
+                    return
+
+            else:
+                raise Exception('Infinite loop')
+
+    def _handle_confirmation_request(self) -> UserConfirmation:
+        """Handle confirmation request from user.
+
+        Returns:
+            UserConfirmation indicating the user's choice
+        """
+
+        pending_actions = ConversationState.get_unmatched_actions(
+            self.conversation.state.events
+        )
+        if not pending_actions:
+            return UserConfirmation.ACCEPT
+
+        result = ask_user_confirmation(
+            pending_actions,
+            isinstance(self.conversation.state.confirmation_policy, ConfirmRisky),
+        )
+        decision = result.decision
+        policy_change = result.policy_change
+
+        if decision == UserConfirmation.REJECT:
+            self.conversation.reject_pending_actions(
+                result.reason or 'User rejected the actions'
+            )
+            return decision
+
+        if decision == UserConfirmation.DEFER:
+            self.conversation.pause()
+            return decision
+
+        if isinstance(policy_change, NeverConfirm):
+            print_formatted_text(
+                HTML(
+                    '<yellow>Confirmation mode disabled. Agent will proceed without asking.</yellow>'
+                )
+            )
+
+            # Remove security analyzer when policy is never confirm
+            self.toggle_confirmation_mode()
+            return decision
+
+        if isinstance(policy_change, ConfirmRisky):
+            print_formatted_text(
+                HTML(
+                    '<yellow>Security-based confirmation enabled. '
+                    'LOW/MEDIUM risk actions will auto-confirm, HIGH risk actions will ask for confirmation.</yellow>'
+                )
+            )
+
+            # Keep security analyzer, change existing policy
+            self.set_confirmation_policy(policy_change)
+            return decision
+
+        # Accept action without changing existing policies
+        assert decision == UserConfirmation.ACCEPT
+        return decision

openhands_cli/setup.py

@@ -0,0 +1,116 @@
+import uuid
+
+from prompt_toolkit import HTML, print_formatted_text
+
+from openhands.sdk import BaseConversation, Conversation, Workspace, register_tool
+from openhands.tools.execute_bash import BashTool
+from openhands.tools.file_editor import FileEditorTool
+from openhands.tools.task_tracker import TaskTrackerTool
+from openhands_cli.listeners import LoadingContext
+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_cli.tui.settings.settings_screen import SettingsScreen
+
+
+register_tool('BashTool', BashTool)
+register_tool('FileEditorTool', FileEditorTool)
+register_tool('TaskTrackerTool', TaskTrackerTool)
+
+
+class MissingAgentSpec(Exception):
+    """Raised when agent specification is not found or invalid."""
+
+    pass
+
+
+def setup_conversation(
+    conversation_id: str | None = None,
+    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.
+    """
+
+    # Use provided conversation_id or generate a random one
+    if conversation_id is None:
+        conversation_id = uuid.uuid4()
+    elif isinstance(conversation_id, str):
+        try:
+            conversation_id = uuid.UUID(conversation_id)
+        except ValueError as e:
+            print_formatted_text(
+                HTML(
+                    f"<yellow>Warning: '{conversation_id}' is not a valid UUID.</yellow>"
+                )
+            )
+            raise e
+
+    with LoadingContext('Initializing OpenHands agent...'):
+        agent_store = AgentStore()
+        agent = agent_store.load(session_id=str(conversation_id))
+        if not agent:
+            raise MissingAgentSpec(
+                'Agent specification not found. Please configure your agent settings.'
+            )
+
+
+        if not include_security_analyzer:
+            # Remove security analyzer from agent spec
+            agent = agent.model_copy(
+                update={"security_analyzer": None}
+            )
+
+        # 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,
+        )
+
+        if include_security_analyzer:
+            conversation.set_confirmation_policy(AlwaysConfirm())
+
+    print_formatted_text(
+        HTML(f'<green>✓ Agent initialized with model: {agent.llm.model}</green>')
+    )
+    return conversation
+
+
+
+def start_fresh_conversation(
+    resume_conversation_id: str | None = None
+) -> BaseConversation:
+    """Start a fresh conversation by creating a new conversation instance.
+
+    Handles the complete conversation setup process including settings screen
+    if agent configuration is missing.
+
+    Args:
+        resume_conversation_id: Optional conversation ID to resume
+
+    Returns:
+        BaseConversation: A new conversation instance
+    """
+    conversation = None
+    settings_screen = SettingsScreen()
+    try:
+        conversation = setup_conversation(resume_conversation_id)
+        return conversation
+    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 setup_conversation(resume_conversation_id)

openhands_cli/simple_main.py

@@ -0,0 +1,59 @@
+#!/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 sys
+import warnings
+
+debug_env = os.getenv('DEBUG', 'false').lower()
+if debug_env != '1' and debug_env != 'true':
+    logging.disable(logging.WARNING)
+    warnings.filterwarnings('ignore')
+
+from prompt_toolkit import print_formatted_text
+from prompt_toolkit.formatted_text import HTML
+
+from openhands_cli.argparsers.main_parser import create_main_parser
+
+
+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)
+        else:
+            # Default CLI behavior - no subcommand needed
+            # Import agent_chat only when needed
+            from openhands_cli.agent_chat import run_cli_entry
+
+            # Start agent chat
+            run_cli_entry(resume_conversation_id=args.resume)
+    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,5 @@
+from openhands_cli.tui.tui import DEFAULT_STYLE
+
+__all__ = [
+    'DEFAULT_STYLE',
+]