openhands-tools 1.53.0__tar.gz → 1.54.0__tar.gz

{openhands_tools-1.53.0 → openhands_tools-1.54.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openhands-tools
-Version: 1.53.0
+Version: 1.54.0
 Summary: OpenHands Tools - Runtime tools for AI agents
 Project-URL: Source, https://github.com/OpenHands/software-agent-sdk
 Project-URL: Homepage, https://github.com/OpenHands/software-agent-sdk

{openhands_tools-1.53.0 → openhands_tools-1.54.0}/openhands/tools/file_editor/editor.py

@@ -414,11 +414,9 @@ class FileEditor:
             )
 
         file_content = self.read_file(path, start_line=start_line, end_line=end_line)
+        file_content = self._normalize_lines(file_content)
 
-        # Get the detected encoding
-        output = self._make_output(
-            "\n".join(file_content.splitlines()), str(path), start_line
-        )  # Remove extra newlines
+        output = self._make_output(file_content, str(path), start_line)
 
         # Prepend warning if we truncated the end_line
         if warning_message:
@@ -787,6 +785,17 @@ class FileEditor:
         except Exception as e:
             raise ToolError(f"Ran into {e} while trying to read {path}") from None
 
+    def _normalize_lines(self, content: str) -> str:
+        """Rejoin a template snippet without folding exotic line separators.
+
+        ``read_file`` returns a snippet whose lines are separated by ``\\n``. The
+        ranged ``view`` path used to round-trip it through ``str.splitlines()``,
+        which also breaks on form feeds and Unicode separators that the rest of
+        the editor treats as ordinary characters, shifting line numbers. Joining
+        on ``\\n`` instead keeps every other character intact.
+        """
+        return "\n".join(content.split("\n"))
+
     def _make_output(
         self,
         snippet_content: str,
@@ -815,14 +824,17 @@ class FileEditor:
             truncate_notice=TEXT_FILE_CONTENT_TRUNCATED_NOTICE,
         )
 
+        # Split on "\n" only, matching how read_file/_count_lines define lines, so that
+        # characters splitlines() treats as breaks (\x0c, \u2028, ...) keep line numbers
+        # consistent with insert/view_range. A terminating newline ends the last line
+        # rather than adding a blank one, so drop the empty field it produces.
+        lines = snippet_content.split("\n")
+        if lines[-1] == "":
+            lines.pop()
         snippet_content = "\n".join(
-            [
-                f"{i + start_line:6}\t{line}"
-                for i, line in enumerate(snippet_content.split("\n"))
-            ]
-        )
-        return (
-            f"Here's the result of running `cat -n` on {snippet_description}:\n"
-            + snippet_content
-            + "\n"
+            [f"{i + start_line:6}\t{line}" for i, line in enumerate(lines)]
         )
+        output = f"Here's the result of running `cat -n` on {snippet_description}:\n"
+        if snippet_content:
+            output += snippet_content + "\n"
+        return output

{openhands_tools-1.53.0 → openhands_tools-1.54.0}/openhands/tools/file_editor/utils/encoding.py

@@ -1,5 +1,6 @@
 """Encoding management for file operations."""
 
+import codecs
 import functools
 import inspect
 import os
@@ -22,7 +23,8 @@ BINARY_CONTROL_CHARS = re.compile(r"[\x00-\x08\x0e-\x1f\x7f]")
 # file's encoding. Short non-UTF-8 files fall below the detector's confidence
 # threshold and are reported as the default encoding, so the detected value
 # alone is not enough to recover them. Ordered most to least likely for source
-# files; the detector's own guess is tried first when it is one of these.
+# files; the detector's own guess is tried right after UTF-8 when it is one of
+# these.
 TEXT_DECODE_CANDIDATES = ("utf-8", "cp1252", "latin-1", "cp1251")
 
 # charset_normalizer reports some codecs under IANA names; map them to the
@@ -70,6 +72,16 @@ class EncodingManager:
         with open(path, "rb") as f:
             raw_data = f.read(sample_size)
 
+        if raw_data.startswith(codecs.BOM_UTF8):
+            return "utf-8-sig"
+
+        try:
+            raw_data.decode(self.default_encoding)
+        except UnicodeDecodeError:
+            pass
+        else:
+            return self.default_encoding
+
         # Use charset_normalizer instead of chardet
         results = charset_normalizer.detect(raw_data)
 
@@ -116,7 +128,11 @@ class EncodingManager:
 
     def _recover_encoding(self, path: Path) -> str | None:
         """Return a codec that decodes ``path`` to control-byte-free text."""
-        candidates = (self._best_guess_encoding(path), *TEXT_DECODE_CANDIDATES)
+        candidates = (
+            self.default_encoding,
+            self._best_guess_encoding(path),
+            *TEXT_DECODE_CANDIDATES,
+        )
         for candidate in dict.fromkeys(c for c in candidates if c):
             try:
                 text = path.read_text(encoding=candidate)

{openhands_tools-1.53.0 → openhands_tools-1.54.0}/openhands/tools/terminal/terminal/terminal_session.py

@@ -2,6 +2,7 @@
 
 import re
 import time
+import uuid
 from enum import Enum
 
 from openhands.sdk.logger import get_logger
@@ -25,6 +26,7 @@ from openhands.tools.terminal.terminal.interface import (
 from openhands.tools.terminal.timeout_policy import foreground_timeout_rejection_for
 from openhands.tools.terminal.utils.command import (
     escape_bash_special_chars,
+    needs_heredoc_completion_boundary,
     split_bash_commands,
 )
 from openhands.tools.terminal.utils.escape_filter import TerminalQueryFilter
@@ -43,8 +45,51 @@ class TerminalCommandStatus(Enum):
     HARD_TIMEOUT = "hard_timeout"
 
 
+def _normalize_echo_line(line: str) -> str:
+    """Collapse an echoed line for comparison against what was sent.
+
+    Different backends alter the echo: readline drops leading tabs (tmux) or
+    substitutes a BEL for each of them (subprocess). Ignore whitespace and
+    control characters so the comparison still recognizes the echo.
+    """
+    return re.sub(r"[\x00-\x1f\x7f]", "", line).strip()
+
+
 def _remove_command_prefix(command_output: str, command: str) -> str:
-    return command_output.lstrip().removeprefix(command.lstrip()).lstrip()
+    """Strip the terminal's echo of `command` from the front of the output.
+
+    readline consumes or rewrites leading tabs when echoing a line, so the echo
+    can differ from the text that was sent by whitespace alone. An exact prefix
+    match then fails and the whole wrapper (plus both halves of the completion
+    marker) leaks into the observation, so fall back to comparing line by line
+    with whitespace and control characters normalized.
+    """
+    stripped = command_output.lstrip()
+    cmd = command.lstrip()
+    if stripped.startswith(cmd):
+        return stripped[len(cmd) :].lstrip()
+
+    if not cmd:
+        return stripped
+    out_lines = stripped.split("\n")
+    cmd_lines = cmd.split("\n")
+    for index, cmd_line in enumerate(cmd_lines):
+        if index >= len(out_lines) or _normalize_echo_line(
+            out_lines[index]
+        ) != _normalize_echo_line(cmd_line):
+            # Not an echo of this command; leave the output untouched.
+            return stripped
+    return "\n".join(out_lines[len(cmd_lines) :]).lstrip()
+
+
+def _remove_echoed_line(command_output: str, command: str) -> str:
+    """Remove one generated command echo wherever it appears in the output."""
+    target = _normalize_echo_line(command)
+    return "".join(
+        line
+        for line in command_output.splitlines(keepends=True)
+        if _normalize_echo_line(line) != target
+    )
 
 
 def _remove_powershell_echo(command_output: str, command: str) -> str:
@@ -91,6 +136,11 @@ class TerminalSession(TerminalSessionBase):
         # Store the last command for interactive input handling
         self.prev_status = None
         self.prev_output = ""
+        # Completion suffix for a heredoc script. Keep it on the session so a
+        # timeout or follow-up poll can recognize and strip it too.
+        self._boundary_marker: re.Pattern[str] | None = None
+        self._boundary_echo: str | None = None
+        self._wrapper_echo: str | None = None
         # Stateful filter for terminal query sequences (handles split sequences)
         self._query_filter = TerminalQueryFilter()
 
@@ -192,15 +242,18 @@ class TerminalSession(TerminalSessionBase):
         command: str,
         terminal_content: str,
         ps1_matches: list[re.Match],
+        echoed_command: str | None = None,
+        boundary_exit_code: int | None = None,
     ) -> TerminalObservation:
         """Handle a completed command."""
         is_special_key = self._is_special_key(command)
+        output_command = echoed_command or command
 
         # When PS1 metadata markers are missing (e.g., corrupted by TUI/ANSI
         # output or scrolled off-screen), fall back gracefully instead of
         # crashing. The command likely completed but we can't extract the
         # exit code or working directory.
-        if len(ps1_matches) == 0:
+        if len(ps1_matches) == 0 and boundary_exit_code is None:
             logger.warning(
                 "No PS1 metadata found in terminal output. "
                 "Command output may have overwritten the markers "
@@ -213,7 +266,7 @@ class TerminalSession(TerminalSessionBase):
                 "PS1 metadata markers.]"
             )
             command_output = self._get_command_output(
-                command,
+                output_command,
                 terminal_content,
                 metadata,
                 is_final=True,
@@ -232,35 +285,36 @@ class TerminalSession(TerminalSessionBase):
                 exit_code=metadata.exit_code,
             )
 
-        metadata = CmdOutputMetadata.from_ps1_match(ps1_matches[-1])
-
-        # Special case where the previous command output is truncated
-        # due to history limit
-        get_content_before_last_match = bool(len(ps1_matches) == 1)
-
-        # Update the current working directory if it has changed
-        if metadata.working_dir != self._cwd and metadata.working_dir:
-            self._cwd: str = metadata.working_dir
+        if boundary_exit_code is not None:
+            metadata = CmdOutputMetadata(
+                exit_code=boundary_exit_code, working_dir=self._cwd
+            )
+            get_content_before_last_match = False
+            raw_command_output = self._combine_outputs_between_matches(
+                terminal_content, ps1_matches
+            )
+        else:
+            metadata = CmdOutputMetadata.from_ps1_match(ps1_matches[-1])
+            get_content_before_last_match = bool(len(ps1_matches) == 1)
+            if metadata.working_dir != self._cwd and metadata.working_dir:
+                self._cwd = metadata.working_dir
+            raw_command_output = self._combine_outputs_between_matches(
+                terminal_content,
+                ps1_matches,
+                get_content_before_last_match=get_content_before_last_match,
+            )
+            if get_content_before_last_match:
+                num_lines = len(raw_command_output.splitlines())
+                metadata.prefix = (
+                    f"[Previous command outputs are truncated. "
+                    f"Showing the last {num_lines} lines of the output below.]\n"
+                )
 
         logger.debug(
             "Parsed terminal output (previous_ps1_not_matched=%s, content_length=%s)",
             get_content_before_last_match,
             len(terminal_content),
         )
-        # Extract the command output between the two PS1 prompts
-        raw_command_output = self._combine_outputs_between_matches(
-            terminal_content,
-            ps1_matches,
-            get_content_before_last_match=get_content_before_last_match,
-        )
-
-        if get_content_before_last_match:
-            # Count the number of lines in the truncated output
-            num_lines = len(raw_command_output.splitlines())
-            metadata.prefix = (
-                f"[Previous command outputs are truncated. "
-                f"Showing the last {num_lines} lines of the output below.]\n"
-            )
 
         metadata.suffix = (
             f"\n[The command completed with exit code {metadata.exit_code}.]"
@@ -271,7 +325,7 @@ class TerminalSession(TerminalSessionBase):
             )
         )
         command_output = self._get_command_output(
-            command,
+            output_command,
             raw_command_output,
             metadata,
             is_final=True,  # Command completed, flush filter state
@@ -296,6 +350,7 @@ class TerminalSession(TerminalSessionBase):
         command: str,
         terminal_content: str,
         ps1_matches: list[re.Match],
+        echoed_command: str | None = None,
     ) -> TerminalObservation:
         """Handle a command that timed out due to no output change."""
         self.prev_status = TerminalCommandStatus.NO_CHANGE_TIMEOUT
@@ -315,7 +370,7 @@ class TerminalSession(TerminalSessionBase):
             f"{self.no_change_timeout_seconds} seconds. {TIMEOUT_MESSAGE_TEMPLATE}]"
         )
         command_output = self._get_command_output(
-            command,
+            echoed_command or command,
             raw_command_output,
             metadata,
             continue_prefix="[Below is the output of the previous command.]\n",
@@ -336,6 +391,7 @@ class TerminalSession(TerminalSessionBase):
         terminal_content: str,
         ps1_matches: list[re.Match],
         timeout: float,
+        echoed_command: str | None = None,
     ) -> TerminalObservation:
         """Handle a command that timed out due to hard timeout."""
         self.prev_status = TerminalCommandStatus.HARD_TIMEOUT
@@ -355,7 +411,7 @@ class TerminalSession(TerminalSessionBase):
             f"{TIMEOUT_MESSAGE_TEMPLATE}]"
         )
         command_output = self._get_command_output(
-            command,
+            echoed_command or command,
             raw_command_output,
             metadata,
             continue_prefix="[Below is the output of the previous command.]\n",
@@ -375,6 +431,24 @@ class TerminalSession(TerminalSessionBase):
         # Clear the current content
         self.terminal.clear_screen()
 
+    def _strip_boundary_wrapper(self, terminal_content: str) -> str:
+        """Remove the heredoc completion suffix from a raw screen read."""
+        if self._boundary_marker is not None:
+            terminal_content = self._boundary_marker.sub("", terminal_content)
+            terminal_content = terminal_content.replace("\x1b[?2004l", "").replace(
+                "\x1b[?2004h", ""
+            )
+        if self._boundary_echo:
+            terminal_content = terminal_content.replace(self._boundary_echo, "")
+            terminal_content = _remove_echoed_line(
+                terminal_content, self._boundary_echo
+            )
+        if self._wrapper_echo:
+            terminal_content = _remove_command_prefix(
+                terminal_content, self._wrapper_echo
+            )
+        return terminal_content
+
     def _combine_outputs_between_matches(
         self,
         terminal_content: str,
@@ -494,6 +568,7 @@ class TerminalSession(TerminalSessionBase):
             and not is_input
             and command != ""
         ):
+            last_terminal_output = self._strip_boundary_wrapper(last_terminal_output)
             _ps1_matches = CmdOutputMetadata.matches_ps1_metadata(last_terminal_output)
             # Use initial_ps1_matches if _ps1_matches is empty,
             # otherwise use _ps1_matches. This handles the case where
@@ -533,6 +608,32 @@ class TerminalSession(TerminalSessionBase):
             )
             return obs
 
+        command_to_send = command
+        boundary_command: str | None = None
+        command_boundary_marker: re.Pattern[str] | None = None
+        if command and not is_input:
+            self._boundary_marker = None
+            self._boundary_echo = None
+            self._wrapper_echo = None
+        if command and not is_input and not self.terminal.is_powershell():
+            if needs_heredoc_completion_boundary(command_to_send):
+                marker_id = uuid.uuid4().hex
+                marker_start = f"__OH_COMMAND_FINISHED_{marker_id}_"
+                marker_end = "__"
+                command_boundary_marker = re.compile(
+                    rf"{re.escape(marker_start)}(?P<exit_code>\d+){marker_end}"
+                )
+                boundary_command = (
+                    "(__openhands_status=$?; printf '\\n%s%s%s\\n' "
+                    f"'{marker_start}' \"$__openhands_status\" '{marker_end}' "
+                    '> /dev/tty; exit "$__openhands_status")'
+                )
+                self._boundary_marker = command_boundary_marker
+            command_to_send = escape_bash_special_chars(command_to_send)
+            if boundary_command is not None:
+                self._boundary_echo = boundary_command
+                self._wrapper_echo = command_to_send
+
         # Send actual command/inputs to the terminal
         sent_command = command != ""
         if command != "":
@@ -546,15 +647,15 @@ class TerminalSession(TerminalSessionBase):
                     enter=not is_special_key,
                 )
             else:
-                # convert command to raw string (for bash terminals)
-                if not self.terminal.is_powershell():
-                    # Only escape for bash terminals, not PowerShell
-                    command = escape_bash_special_chars(command)
-                logger.debug("Sending command (command_length=%s)", len(command))
+                logger.debug(
+                    "Sending command (command_length=%s)", len(command_to_send)
+                )
                 self.terminal.send_keys(
-                    command,
+                    command_to_send,
                     enter=not is_special_key,
                 )
+                if boundary_command is not None:
+                    self.terminal.send_keys(boundary_command)
 
         # Loop until the command completes or times out
         while True:
@@ -572,25 +673,47 @@ class TerminalSession(TerminalSessionBase):
             output_changed_since_command = (
                 cur_terminal_output != initial_terminal_output
             )
+            active_boundary_marker = command_boundary_marker or self._boundary_marker
+            boundary_match = (
+                active_boundary_marker.search(cur_terminal_output)
+                if active_boundary_marker is not None
+                else None
+            )
+            command_reached_boundary = (
+                active_boundary_marker is None or boundary_match is not None
+            )
 
             if cur_terminal_output != last_terminal_output:
                 last_terminal_output = cur_terminal_output
                 last_change_time = time.time()
                 logger.debug(f"CONTENT UPDATED DETECTED at {last_change_time}")
 
-            # 1) Execution completed:
-            # Condition 1: A new prompt has appeared since the command started.
-            # Condition 2: The prompt count hasn't increased (potentially because the
-            # initial one scrolled off), BUT the *current* visible terminal ends with a
-            # prompt, indicating completion.
-            if (not sent_command or output_changed_since_command) and (
-                current_ps1_count > initial_ps1_count
-                or cur_terminal_output.rstrip().endswith(CMD_OUTPUT_PS1_END.rstrip())
+            # 1) Execution completed when a prompt appears, or when a heredoc
+            # suffix reaches its tty boundary after stdout has been redirected.
+            prompt_reached = current_ps1_count > initial_ps1_count or (
+                cur_terminal_output.rstrip().endswith(CMD_OUTPUT_PS1_END.rstrip())
+            )
+            if (
+                command_reached_boundary
+                and (not sent_command or output_changed_since_command)
+                and (prompt_reached or boundary_match is not None)
             ):
+                completed_terminal_output = cur_terminal_output
+                boundary_exit_code = None
+                if active_boundary_marker is not None:
+                    completed_terminal_output = self._strip_boundary_wrapper(
+                        completed_terminal_output
+                    )
+                    if not prompt_reached and boundary_match is not None:
+                        boundary_exit_code = int(boundary_match.group("exit_code"))
+                completed_ps1_matches = CmdOutputMetadata.matches_ps1_metadata(
+                    completed_terminal_output
+                )
                 obs = self._handle_completed_command(
                     command,
-                    terminal_content=cur_terminal_output,
-                    ps1_matches=ps1_matches,
+                    terminal_content=completed_terminal_output,
+                    ps1_matches=completed_ps1_matches,
+                    boundary_exit_code=boundary_exit_code,
                 )
                 return obs
 
@@ -610,10 +733,14 @@ class TerminalSession(TerminalSessionBase):
                 and self.no_change_timeout_seconds is not None
                 and time_since_last_change >= self.no_change_timeout_seconds
             ):
+                stripped_output = self._strip_boundary_wrapper(cur_terminal_output)
                 obs = self._handle_nochange_timeout_command(
                     command,
-                    terminal_content=cur_terminal_output,
-                    ps1_matches=ps1_matches,
+                    terminal_content=stripped_output,
+                    ps1_matches=CmdOutputMetadata.matches_ps1_metadata(stripped_output),
+                    echoed_command=(
+                        command_to_send if command_boundary_marker is not None else None
+                    ),
                 )
                 return obs
 
@@ -626,11 +753,19 @@ class TerminalSession(TerminalSessionBase):
             if action.timeout is not None:
                 time_since_start = time.time() - start_time
                 if time_since_start >= action.timeout:
+                    stripped_output = self._strip_boundary_wrapper(cur_terminal_output)
                     obs = self._handle_hard_timeout_command(
                         command,
-                        terminal_content=cur_terminal_output,
-                        ps1_matches=ps1_matches,
+                        terminal_content=stripped_output,
+                        ps1_matches=CmdOutputMetadata.matches_ps1_metadata(
+                            stripped_output
+                        ),
                         timeout=action.timeout,
+                        echoed_command=(
+                            command_to_send
+                            if command_boundary_marker is not None
+                            else None
+                        ),
                     )
                     return obs
 

openhands_tools-1.54.0/openhands/tools/terminal/utils/command.py

@@ -0,0 +1,195 @@
+"""Command splitting and escape utilities backed by tree-sitter-bash."""
+
+import re
+
+from tree_sitter import Node
+
+from openhands.sdk.logger import get_logger
+from openhands.sdk.security.shell_parser import parse
+
+
+logger = get_logger(__name__)
+
+# Regions whose contents bash takes verbatim — escape doubling stops at
+# their boundaries so operators nested inside (e.g.) a double-quoted
+# string remain untouched. Walking does not recurse into these nodes.
+_PRESERVE_TYPES: frozenset[str] = frozenset(
+    {
+        "string",
+        "raw_string",
+        "ansi_c_string",
+        "translated_string",
+        "command_substitution",
+        "expansion",
+        "simple_expansion",
+        "heredoc_body",
+        "comment",
+    }
+)
+
+_ESCAPE_PATTERN: re.Pattern[bytes] = re.compile(rb"\\([;&|<>])")
+
+
+def _ends_with_heredoc(node: Node) -> bool:
+    """Whether ``node``'s final token is a heredoc terminator.
+
+    Checking only that the last *named* descendant is a ``heredoc_end`` is not
+    enough: tree-sitter leaves closing tokens such as ``fi``, ``done``, and
+    ``)`` unnamed, so a compound statement or substitution that merely
+    *contains* a heredoc would match and swallow the newline that actually ends
+    the statement. Require the terminator to reach ``node``'s end too.
+    """
+    last = node
+    while last.named_children:
+        last = last.named_children[-1]
+    return last.type == "heredoc_end" and last.end_byte == node.end_byte
+
+
+def _last_heredoc_is_closed(root: Node) -> bool:
+    """Whether the final heredoc in an unparseable input has seen its terminator.
+
+    tree-sitter-bash reports a parse error for forms bash itself accepts (a
+    quoted delimiter, several heredocs on one command, ``&`` before the body)
+    and may then omit the ``heredoc_end`` node, leaving the terminator line
+    inside the ``heredoc_body`` instead. Compare that final line against the
+    delimiter to tell a closed heredoc from one bash is still reading. Deciding
+    from the tree keeps the guard identical on every platform instead of
+    depending on a ``bash`` executable being present and working.
+    """
+    entries: list[tuple[int, str, bytes]] = []
+    stack = [root]
+    while stack:
+        node = stack.pop()
+        if node.type in ("heredoc_start", "heredoc_body", "heredoc_end"):
+            entries.append((node.start_byte, node.type, node.text or b""))
+        stack.extend(node.named_children)
+    entries.sort()
+
+    start = max(
+        (
+            index
+            for index, (_, kind, _) in enumerate(entries)
+            if kind == "heredoc_start"
+        ),
+        default=None,
+    )
+    if start is None:
+        return False
+    delimiter = re.sub(r"['\"]", "", entries[start][2].decode().strip())
+    if delimiter.startswith("-"):
+        delimiter = delimiter[1:]
+    rest = entries[start + 1 :]
+    if any(kind == "heredoc_end" for _, kind, _ in rest):
+        return True
+    bodies = [text for _, kind, text in rest if kind == "heredoc_body"]
+    if not bodies:
+        return False
+    lines = [line for line in bodies[-1].decode().splitlines() if line.strip()]
+    return bool(lines) and lines[-1].strip() == delimiter
+
+
+def needs_heredoc_completion_boundary(commands: str) -> bool:
+    """Whether interactive Bash may prompt before this input is fully consumed."""
+    source = commands.encode()
+    result = parse(commands)
+    root = result.tree.root_node
+    if result.has_error:
+        stack = [root]
+        has_heredoc = False
+        while stack:
+            node = stack.pop()
+            has_heredoc = has_heredoc or node.type.startswith("heredoc_")
+            stack.extend(node.named_children)
+        if not has_heredoc:
+            return False
+        return _last_heredoc_is_closed(root)
+
+    statements = [child for child in root.named_children if child.type != "comment"]
+    return any(
+        _ends_with_heredoc(current)
+        and b"\n" in source[current.end_byte : following.start_byte]
+        for current, following in zip(statements, statements[1:])
+    )
+
+
+def split_bash_commands(commands: str) -> list[str]:
+    """Split a multi-statement bash input into top-level statements.
+
+    Statements separated by a newline (with or without intermediate
+    whitespace/comments) become separate entries, except after a completed
+    heredoc. Statements joined by ``;``, ``&&``, ``||``, ``|``, or ``&`` stay
+    together. Comments and whitespace between two statements are folded into
+    the preceding entry. On parse failure the input is returned as a
+    single-element list.
+    """
+    if not commands.strip():
+        return [""]
+
+    source = commands.encode()
+    result = parse(commands)
+    root = result.tree.root_node
+
+    if result.has_error:
+        logger.debug(
+            "tree-sitter-bash reported parse errors; returning input as-is\n"
+            "[input]: %s",
+            commands,
+        )
+        return [commands]
+
+    statements = [c for c in root.named_children if c.type != "comment"]
+    if not statements:
+        return [commands]
+
+    boundaries = [statements[0].start_byte]
+    for cur, nxt in zip(statements, statements[1:]):
+        if b"\n" in source[cur.end_byte : nxt.start_byte] and not _ends_with_heredoc(
+            cur
+        ):
+            boundaries.append(nxt.start_byte)
+    boundaries.append(len(source))
+
+    return [source[a:b].decode().rstrip() for a, b in zip(boundaries, boundaries[1:])]
+
+
+def escape_bash_special_chars(command: str) -> str:
+    r"""Double the escape on ``\;``, ``\&``, ``\|``, ``\<``, ``\>``.
+
+    Sequences inside regions bash takes verbatim — single- and
+    double-quoted strings, command substitutions, parameter expansions,
+    heredoc bodies, and comments — are left untouched. On parse failure
+    the input is returned unchanged.
+    """
+    if command.strip() == "":
+        return ""
+
+    source = command.encode()
+    result = parse(command)
+    if result.has_error:
+        logger.debug(
+            "tree-sitter-bash reported parse errors; returning input as-is\n"
+            "[input]: %s",
+            command,
+        )
+        return command
+
+    preserved: list[tuple[int, int]] = []
+
+    def collect(node: Node) -> None:
+        if node.type in _PRESERVE_TYPES:
+            preserved.append((node.start_byte, node.end_byte))
+            return
+        for child in node.children:
+            collect(child)
+
+    collect(result.tree.root_node)
+
+    out = bytearray()
+    cursor = 0
+    for start, end in preserved:
+        out.extend(_ESCAPE_PATTERN.sub(rb"\\\\\1", source[cursor:start]))
+        out.extend(source[start:end])
+        cursor = end
+    out.extend(_ESCAPE_PATTERN.sub(rb"\\\\\1", source[cursor:]))
+
+    return out.decode()

{openhands_tools-1.53.0 → openhands_tools-1.54.0}/openhands_tools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openhands-tools
-Version: 1.53.0
+Version: 1.54.0
 Summary: OpenHands Tools - Runtime tools for AI agents
 Project-URL: Source, https://github.com/OpenHands/software-agent-sdk
 Project-URL: Homepage, https://github.com/OpenHands/software-agent-sdk

{openhands_tools-1.53.0 → openhands_tools-1.54.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "openhands-tools"
-version = "1.53.0"
+version = "1.54.0"
 description = "OpenHands Tools - Runtime tools for AI agents"
 
 requires-python = ">=3.12"

openhands_tools-1.53.0/openhands/tools/terminal/utils/command.py

@@ -1,111 +0,0 @@
-"""Command splitting and escape utilities backed by tree-sitter-bash."""
-
-import re
-
-from tree_sitter import Node
-
-from openhands.sdk.logger import get_logger
-from openhands.sdk.security.shell_parser import parse
-
-
-logger = get_logger(__name__)
-
-# Regions whose contents bash takes verbatim — escape doubling stops at
-# their boundaries so operators nested inside (e.g.) a double-quoted
-# string remain untouched. Walking does not recurse into these nodes.
-_PRESERVE_TYPES: frozenset[str] = frozenset(
-    {
-        "string",
-        "raw_string",
-        "ansi_c_string",
-        "translated_string",
-        "command_substitution",
-        "expansion",
-        "simple_expansion",
-        "heredoc_body",
-        "comment",
-    }
-)
-
-_ESCAPE_PATTERN: re.Pattern[bytes] = re.compile(rb"\\([;&|<>])")
-
-
-def split_bash_commands(commands: str) -> list[str]:
-    """Split a multi-statement bash input into top-level statements.
-
-    Statements separated by a newline (with or without intermediate
-    whitespace/comments) become separate entries; statements joined by
-    ``;``, ``&&``, ``||``, ``|``, or ``&`` stay together. Comments and
-    whitespace between two statements are folded into the preceding
-    entry. On parse failure the input is returned as a single-element
-    list.
-    """
-    if not commands.strip():
-        return [""]
-
-    source = commands.encode()
-    result = parse(commands)
-    root = result.tree.root_node
-
-    if result.has_error:
-        logger.debug(
-            "tree-sitter-bash reported parse errors; returning input as-is\n"
-            "[input]: %s",
-            commands,
-        )
-        return [commands]
-
-    statements = [c for c in root.named_children if c.type != "comment"]
-    if not statements:
-        return [commands]
-
-    boundaries = [statements[0].start_byte]
-    for cur, nxt in zip(statements, statements[1:]):
-        if b"\n" in source[cur.end_byte : nxt.start_byte]:
-            boundaries.append(nxt.start_byte)
-    boundaries.append(len(source))
-
-    return [source[a:b].decode().rstrip() for a, b in zip(boundaries, boundaries[1:])]
-
-
-def escape_bash_special_chars(command: str) -> str:
-    r"""Double the escape on ``\;``, ``\&``, ``\|``, ``\<``, ``\>``.
-
-    Sequences inside regions bash takes verbatim — single- and
-    double-quoted strings, command substitutions, parameter expansions,
-    heredoc bodies, and comments — are left untouched. On parse failure
-    the input is returned unchanged.
-    """
-    if command.strip() == "":
-        return ""
-
-    source = command.encode()
-    result = parse(command)
-    if result.has_error:
-        logger.debug(
-            "tree-sitter-bash reported parse errors; returning input as-is\n"
-            "[input]: %s",
-            command,
-        )
-        return command
-
-    preserved: list[tuple[int, int]] = []
-
-    def collect(node: Node) -> None:
-        if node.type in _PRESERVE_TYPES:
-            preserved.append((node.start_byte, node.end_byte))
-            return
-        for child in node.children:
-            collect(child)
-
-    collect(result.tree.root_node)
-
-    out = bytearray()
-    cursor = 0
-    for start, end in preserved:
-        out.extend(_ESCAPE_PATTERN.sub(rb"\\\\\1", source[cursor:start]))
-        out.extend(source[start:end])
-        cursor = end
-    out.extend(_ESCAPE_PATTERN.sub(rb"\\\\\1", source[cursor:]))
-
-    return out.decode()