openhands 1.3.0__py3-none-any.whl

openhands_cli/argparsers/serve_parser.py

@@ -0,0 +1,31 @@
+"""Argument parser for serve subcommand."""
+
+import argparse
+
+
+def add_serve_parser(subparsers: argparse._SubParsersAction) -> argparse.ArgumentParser:
+    """Add serve subcommand parser.
+
+    Args:
+        subparsers: The subparsers object to add the serve parser to
+
+    Returns:
+        The serve argument parser
+    """
+    serve_parser = subparsers.add_parser(
+        "serve", help="Launch the OpenHands GUI server using Docker (web interface)"
+    )
+    serve_parser.add_argument(
+        "--mount-cwd",
+        help="Mount the current working directory into the GUI server container",
+        action="store_true",
+        default=False,
+    )
+    serve_parser.add_argument(
+        "--gpu",
+        help="Enable GPU support by mounting all GPUs into the Docker "
+        "container via nvidia-docker",
+        action="store_true",
+        default=False,
+    )
+    return serve_parser

openhands_cli/gui_launcher.py

@@ -0,0 +1,224 @@
+"""GUI launcher for OpenHands CLI."""
+
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+from prompt_toolkit import print_formatted_text
+from prompt_toolkit.formatted_text import HTML
+
+from openhands_cli.locations import PERSISTENCE_DIR
+
+
+def _format_docker_command_for_logging(cmd: list[str]) -> str:
+    """Format a Docker command for logging with grey color.
+
+    Args:
+        cmd (list[str]): The Docker command as a list of strings
+
+    Returns:
+        str: The formatted command string in grey HTML color
+    """
+    cmd_str = " ".join(cmd)
+    return f"<grey>Running Docker command: {cmd_str}</grey>"
+
+
+def check_docker_requirements() -> bool:
+    """Check if Docker is installed and running.
+
+    Returns:
+        bool: True if Docker is available and running, False otherwise.
+    """
+    # Check if Docker is installed
+    if not shutil.which("docker"):
+        print_formatted_text(
+            HTML("<ansired>❌ Docker is not installed or not in PATH.</ansired>")
+        )
+        print_formatted_text(
+            HTML(
+                "<grey>Please install Docker first: https://docs.docker.com/get-docker/</grey>"
+            )
+        )
+        return False
+
+    # Check if Docker daemon is running
+    try:
+        result = subprocess.run(
+            ["docker", "info"], capture_output=True, text=True, timeout=10
+        )
+        if result.returncode != 0:
+            print_formatted_text(
+                HTML("<ansired>❌ Docker daemon is not running.</ansired>")
+            )
+            print_formatted_text(
+                HTML("<grey>Please start Docker and try again.</grey>")
+            )
+            return False
+    except (subprocess.TimeoutExpired, subprocess.SubprocessError) as e:
+        print_formatted_text(
+            HTML("<ansired>❌ Failed to check Docker status.</ansired>")
+        )
+        print_formatted_text(HTML(f"<grey>Error: {e}</grey>"))
+        return False
+
+    return True
+
+
+def ensure_config_dir_exists() -> Path:
+    """Ensure the OpenHands configuration directory exists and return its path."""
+    path = Path(PERSISTENCE_DIR)
+    path.mkdir(exist_ok=True, parents=True)
+    return path
+
+
+def get_openhands_version() -> str:
+    """Get the OpenHands version for Docker images.
+
+    Returns:
+        str: The version string to use for Docker images
+    """
+    # For now, use 'latest' as the default version
+    # In the future, this could be read from a version file or environment variable
+    return os.environ.get("OPENHANDS_VERSION", "latest")
+
+
+def launch_gui_server(mount_cwd: bool = False, gpu: bool = False) -> None:
+    """Launch the OpenHands GUI server using Docker.
+
+    Args:
+        mount_cwd: If True, mount the current working directory into the container.
+        gpu: If True, enable GPU support by mounting all GPUs into the
+            container via nvidia-docker.
+    """
+    print_formatted_text(
+        HTML("<ansiblue>🚀 Launching OpenHands GUI server...</ansiblue>")
+    )
+    print_formatted_text("")
+
+    # Check Docker requirements
+    if not check_docker_requirements():
+        sys.exit(1)
+
+    # Ensure config directory exists
+    config_dir = ensure_config_dir_exists()
+
+    # Get the current version for the Docker image
+    version = get_openhands_version()
+    runtime_image = f"docker.openhands.dev/openhands/runtime:{version}-nikolaik"
+    app_image = f"docker.openhands.dev/openhands/openhands:{version}"
+
+    print_formatted_text(HTML("<grey>Pulling required Docker images...</grey>"))
+
+    # Pull the runtime image first
+    pull_cmd = ["docker", "pull", runtime_image]
+    print_formatted_text(HTML(_format_docker_command_for_logging(pull_cmd)))
+    try:
+        subprocess.run(pull_cmd, check=True)
+    except subprocess.CalledProcessError:
+        print_formatted_text(
+            HTML("<ansired>❌ Failed to pull runtime image.</ansired>")
+        )
+        sys.exit(1)
+
+    print_formatted_text("")
+    print_formatted_text(
+        HTML("<ansigreen>✅ Starting OpenHands GUI server...</ansigreen>")
+    )
+    print_formatted_text(
+        HTML("<grey>The server will be available at: http://localhost:3000</grey>")
+    )
+    print_formatted_text(HTML("<grey>Press Ctrl+C to stop the server.</grey>"))
+    print_formatted_text("")
+
+    # Build the Docker command
+    docker_cmd = [
+        "docker",
+        "run",
+        "-it",
+        "--rm",
+        "--pull=always",
+        "-e",
+        f"SANDBOX_RUNTIME_CONTAINER_IMAGE={runtime_image}",
+        "-e",
+        "LOG_ALL_EVENTS=true",
+        "-v",
+        "/var/run/docker.sock:/var/run/docker.sock",
+        "-v",
+        f"{config_dir}:/.openhands",
+    ]
+
+    # Add GPU support if requested
+    if gpu:
+        print_formatted_text(
+            HTML("<ansigreen>🖥️ Enabling GPU support via nvidia-docker...</ansigreen>")
+        )
+        # Add the --gpus all flag to enable all GPUs
+        docker_cmd.insert(2, "--gpus")
+        docker_cmd.insert(3, "all")
+        # Add environment variable to pass GPU support to sandbox containers
+        docker_cmd.extend(
+            [
+                "-e",
+                "SANDBOX_ENABLE_GPU=true",
+            ]
+        )
+
+    # Add current working directory mount if requested
+    if mount_cwd:
+        cwd = Path.cwd()
+        # Following the documentation at https://docs.all-hands.dev/usage/runtimes/docker#connecting-to-your-filesystem
+        docker_cmd.extend(
+            [
+                "-e",
+                f"SANDBOX_VOLUMES={cwd}:/workspace:rw",
+            ]
+        )
+
+        # Set user ID for Unix-like systems only
+        if os.name != "nt":  # Not Windows
+            try:
+                user_id = subprocess.check_output(["id", "-u"], text=True).strip()
+                docker_cmd.extend(["-e", f"SANDBOX_USER_ID={user_id}"])
+            except (subprocess.CalledProcessError, FileNotFoundError):
+                # If 'id' command fails or doesn't exist, skip setting user ID
+                pass
+        # Print the folder that will be mounted to inform the user
+        print_formatted_text(
+            HTML(
+                f"<ansigreen>📂 Mounting current directory:</ansigreen> "
+                f"<ansiyellow>{cwd}</ansiyellow> <ansigreen>to</ansigreen> "
+                f"<ansiyellow>/workspace</ansiyellow>"
+            )
+        )
+
+    docker_cmd.extend(
+        [
+            "-p",
+            "3000:3000",
+            "--add-host",
+            "host.docker.internal:host-gateway",
+            "--name",
+            "openhands-app",
+            app_image,
+        ]
+    )
+
+    try:
+        # Log and run the Docker command
+        print_formatted_text(HTML(_format_docker_command_for_logging(docker_cmd)))
+        subprocess.run(docker_cmd, check=True)
+    except subprocess.CalledProcessError as e:
+        print_formatted_text("")
+        print_formatted_text(
+            HTML("<ansired>❌ Failed to start OpenHands GUI server.</ansired>")
+        )
+        print_formatted_text(HTML(f"<grey>Error: {e}</grey>"))
+        sys.exit(1)
+    except KeyboardInterrupt:
+        print_formatted_text("")
+        print_formatted_text(
+            HTML("<ansigreen>✓ OpenHands GUI server stopped successfully.</ansigreen>")
+        )
+        sys.exit(0)

openhands_cli/listeners/__init__.py

@@ -0,0 +1,4 @@
+from openhands_cli.listeners.pause_listener import PauseListener
+
+
+__all__ = ["PauseListener"]

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/locations.py

@@ -0,0 +1,14 @@
+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,33 @@
+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/OpenHands/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,190 @@
+from prompt_toolkit import HTML, print_formatted_text
+
+from openhands.sdk import BaseConversation, Message
+from openhands.sdk.conversation.state import (
+    ConversationExecutionStatus,
+    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.setup import setup_conversation
+from openhands_cli.user_actions import ask_user_confirmation
+from openhands_cli.user_actions.types import UserConfirmation
+
+
+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.execution_status
+            == ConversationExecutionStatus.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.execution_status
+            == ConversationExecutionStatus.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.execution_status
+                == ConversationExecutionStatus.FINISHED
+            ):
+                break
+
+            elif (
+                self.conversation.state.execution_status
+                == ConversationExecutionStatus.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