janito 2.3.0__py3-none-any.whl → 2.3.1__py3-none-any.whl

janito/tools/adapters/local/run_bash_command.py

@@ -1,176 +1,176 @@
-from janito.tools.tool_base import ToolBase
-from janito.report_events import ReportAction
-from janito.tools.adapters.local.adapter import register_local_tool
-from janito.i18n import tr
-import subprocess
-import tempfile
-import sys
-import os
-import threading
-
-
-@register_local_tool
-class RunBashCommandTool(ToolBase):
-    """
-    Execute a non-interactive command using the bash shell and capture live output.
-    This tool explicitly invokes the 'bash' shell (not just the system default shell), so it requires bash to be installed and available in the system PATH. On Windows, this will only work if bash is available (e.g., via WSL, Git Bash, or similar).
-
-    Parameters:
-        command (str): The bash command to execute.
-        timeout (int): Timeout in seconds for the command. Defaults to 60.
-        require_confirmation (bool): If True, require user confirmation before running. Defaults to False.
-        requires_user_input (bool): If True, warns that the command may require user input and might hang. Defaults to False. Non-interactive commands are preferred for automation and reliability.
-
-    Returns:
-        str: File paths and line counts for stdout and stderr.
-    """
-    provides_execution = True
-    tool_name = "run_bash_command"
-
-    def _stream_output(self, stream, file_obj, report_func, count_func, counter):
-        for line in stream:
-            file_obj.write(line)
-            file_obj.flush()
-            report_func(line.rstrip("\r\n"), ReportAction.EXECUTE)
-            if count_func == "stdout":
-                counter["stdout"] += 1
-            else:
-                counter["stderr"] += 1
-
-    def run(
-        self,
-        command: str,
-        timeout: int = 60,
-        require_confirmation: bool = False,
-        requires_user_input: bool = False,
-    ) -> str:
-        if not command.strip():
-            self.report_warning(tr("ℹ️ Empty command provided."), ReportAction.EXECUTE)
-            return tr("Warning: Empty command provided. Operation skipped.")
-        self.report_action(
-            tr("🖥️ Run bash command: {command} ...\n", command=command),
-            ReportAction.EXECUTE,
-        )
-        if requires_user_input:
-            self.report_warning(
-                tr(
-                    "⚠️  Warning: This command might be interactive, require user input, and might hang."
-                ),
-                ReportAction.EXECUTE,
-            )
-            sys.stdout.flush()
-        try:
-            with (
-                tempfile.NamedTemporaryFile(
-                    mode="w+", prefix="run_bash_stdout_", delete=False, encoding="utf-8"
-                ) as stdout_file,
-                tempfile.NamedTemporaryFile(
-                    mode="w+", prefix="run_bash_stderr_", delete=False, encoding="utf-8"
-                ) as stderr_file,
-            ):
-                env = os.environ.copy()
-                env["PYTHONIOENCODING"] = "utf-8"
-                env["LC_ALL"] = "C.UTF-8"
-                env["LANG"] = "C.UTF-8"
-                process = subprocess.Popen(
-                    ["bash", "-c", command],
-                    stdout=subprocess.PIPE,
-                    stderr=subprocess.PIPE,
-                    text=True,
-                    encoding="utf-8",
-                    bufsize=1,
-                    env=env,
-                )
-                counter = {"stdout": 0, "stderr": 0}
-                stdout_thread = threading.Thread(
-                    target=self._stream_output,
-                    args=(
-                        process.stdout,
-                        stdout_file,
-                        self.report_stdout,
-                        "stdout",
-                        counter,
-                    ),
-                )
-                stderr_thread = threading.Thread(
-                    target=self._stream_output,
-                    args=(
-                        process.stderr,
-                        stderr_file,
-                        self.report_stderr,
-                        "stderr",
-                        counter,
-                    ),
-                )
-                stdout_thread.start()
-                stderr_thread.start()
-                try:
-                    return_code = process.wait(timeout=timeout)
-                except subprocess.TimeoutExpired:
-                    process.kill()
-                    self.report_error(
-                        tr(
-                            " ❌ Timed out after {timeout} seconds.",
-                            timeout=timeout,
-                        ),
-                        ReportAction.EXECUTE,
-                    )
-                    return tr(
-                        "Command timed out after {timeout} seconds.", timeout=timeout
-                    )
-                stdout_thread.join()
-                stderr_thread.join()
-                stdout_file.flush()
-                stderr_file.flush()
-                self.report_success(
-                    tr(
-                        " ✅ return code {return_code}",
-                        return_code=return_code,
-                    ),
-                    ReportAction.EXECUTE,
-                )
-                max_lines = 100
-                # Read back the output for summary
-                stdout_file.seek(0)
-                stderr_file.seek(0)
-                stdout_content = stdout_file.read()
-                stderr_content = stderr_file.read()
-                stdout_lines = counter["stdout"]
-                stderr_lines = counter["stderr"]
-                warning_msg = ""
-                if requires_user_input:
-                    warning_msg = tr(
-                        "⚠️  Warning: This command might be interactive, require user input, and might hang.\n"
-                    )
-                if stdout_lines <= max_lines and stderr_lines <= max_lines:
-                    result = warning_msg + tr(
-                        "Return code: {return_code}\n--- STDOUT ---\n{stdout_content}",
-                        return_code=return_code,
-                        stdout_content=stdout_content,
-                    )
-                    if stderr_content.strip():
-                        result += tr(
-                            "\n--- STDERR ---\n{stderr_content}",
-                            stderr_content=stderr_content,
-                        )
-                    return result
-                else:
-                    result = warning_msg + tr(
-                        "[LARGE OUTPUT]\nstdout_file: {stdout_file} (lines: {stdout_lines})\n",
-                        stdout_file=stdout_file.name,
-                        stdout_lines=stdout_lines,
-                    )
-                    if stderr_lines > 0:
-                        result += tr(
-                            "stderr_file: {stderr_file} (lines: {stderr_lines})\n",
-                            stderr_file=stderr_file.name,
-                            stderr_lines=stderr_lines,
-                        )
-                    result += tr(
-                        "returncode: {return_code}\nUse the view_file tool to inspect the contents of these files when needed.",
-                        return_code=return_code,
-                    )
-                    return result
-        except Exception as e:
-            self.report_error(tr(" ❌ Error: {error}", error=e), ReportAction.EXECUTE)
-            return tr("Error running command: {error}", error=e)
+from janito.tools.tool_base import ToolBase
+from janito.report_events import ReportAction
+from janito.tools.adapters.local.adapter import register_local_tool
+from janito.i18n import tr
+import subprocess
+import tempfile
+import sys
+import os
+import threading
+
+
+@register_local_tool
+class RunBashCommandTool(ToolBase):
+    """
+    Execute a non-interactive command using the bash shell and capture live output.
+    This tool explicitly invokes the 'bash' shell (not just the system default shell), so it requires bash to be installed and available in the system PATH. On Windows, this will only work if bash is available (e.g., via WSL, Git Bash, or similar).
+
+    Parameters:
+        command (str): The bash command to execute.
+        timeout (int): Timeout in seconds for the command. Defaults to 60.
+        require_confirmation (bool): If True, require user confirmation before running. Defaults to False.
+        requires_user_input (bool): If True, warns that the command may require user input and might hang. Defaults to False. Non-interactive commands are preferred for automation and reliability.
+
+    Returns:
+        str: File paths and line counts for stdout and stderr.
+    """
+    provides_execution = True
+    tool_name = "run_bash_command"
+
+    def _stream_output(self, stream, file_obj, report_func, count_func, counter):
+        for line in stream:
+            file_obj.write(line)
+            file_obj.flush()
+            report_func(line.rstrip("\r\n"), ReportAction.EXECUTE)
+            if count_func == "stdout":
+                counter["stdout"] += 1
+            else:
+                counter["stderr"] += 1
+
+    def run(
+        self,
+        command: str,
+        timeout: int = 60,
+        require_confirmation: bool = False,
+        requires_user_input: bool = False,
+    ) -> str:
+        if not command.strip():
+            self.report_warning(tr("ℹ️ Empty command provided."), ReportAction.EXECUTE)
+            return tr("Warning: Empty command provided. Operation skipped.")
+        self.report_action(
+            tr("🖥️ Run bash command: {command} ...\n", command=command),
+            ReportAction.EXECUTE,
+        )
+        if requires_user_input:
+            self.report_warning(
+                tr(
+                    "⚠️  Warning: This command might be interactive, require user input, and might hang."
+                ),
+                ReportAction.EXECUTE,
+            )
+            sys.stdout.flush()
+        try:
+            with (
+                tempfile.NamedTemporaryFile(
+                    mode="w+", prefix="run_bash_stdout_", delete=False, encoding="utf-8"
+                ) as stdout_file,
+                tempfile.NamedTemporaryFile(
+                    mode="w+", prefix="run_bash_stderr_", delete=False, encoding="utf-8"
+                ) as stderr_file,
+            ):
+                env = os.environ.copy()
+                env["PYTHONIOENCODING"] = "utf-8"
+                env["LC_ALL"] = "C.UTF-8"
+                env["LANG"] = "C.UTF-8"
+                process = subprocess.Popen(
+                    ["bash", "-c", command],
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    text=True,
+                    encoding="utf-8",
+                    bufsize=1,
+                    env=env,
+                )
+                counter = {"stdout": 0, "stderr": 0}
+                stdout_thread = threading.Thread(
+                    target=self._stream_output,
+                    args=(
+                        process.stdout,
+                        stdout_file,
+                        self.report_stdout,
+                        "stdout",
+                        counter,
+                    ),
+                )
+                stderr_thread = threading.Thread(
+                    target=self._stream_output,
+                    args=(
+                        process.stderr,
+                        stderr_file,
+                        self.report_stderr,
+                        "stderr",
+                        counter,
+                    ),
+                )
+                stdout_thread.start()
+                stderr_thread.start()
+                try:
+                    return_code = process.wait(timeout=timeout)
+                except subprocess.TimeoutExpired:
+                    process.kill()
+                    self.report_error(
+                        tr(
+                            " ❌ Timed out after {timeout} seconds.",
+                            timeout=timeout,
+                        ),
+                        ReportAction.EXECUTE,
+                    )
+                    return tr(
+                        "Command timed out after {timeout} seconds.", timeout=timeout
+                    )
+                stdout_thread.join()
+                stderr_thread.join()
+                stdout_file.flush()
+                stderr_file.flush()
+                self.report_success(
+                    tr(
+                        " ✅ return code {return_code}",
+                        return_code=return_code,
+                    ),
+                    ReportAction.EXECUTE,
+                )
+                max_lines = 100
+                # Read back the output for summary
+                stdout_file.seek(0)
+                stderr_file.seek(0)
+                stdout_content = stdout_file.read()
+                stderr_content = stderr_file.read()
+                stdout_lines = counter["stdout"]
+                stderr_lines = counter["stderr"]
+                warning_msg = ""
+                if requires_user_input:
+                    warning_msg = tr(
+                        "⚠️  Warning: This command might be interactive, require user input, and might hang.\n"
+                    )
+                if stdout_lines <= max_lines and stderr_lines <= max_lines:
+                    result = warning_msg + tr(
+                        "Return code: {return_code}\n--- STDOUT ---\n{stdout_content}",
+                        return_code=return_code,
+                        stdout_content=stdout_content,
+                    )
+                    if stderr_content.strip():
+                        result += tr(
+                            "\n--- STDERR ---\n{stderr_content}",
+                            stderr_content=stderr_content,
+                        )
+                    return result
+                else:
+                    result = warning_msg + tr(
+                        "[LARGE OUTPUT]\nstdout_file: {stdout_file} (lines: {stdout_lines})\n",
+                        stdout_file=stdout_file.name,
+                        stdout_lines=stdout_lines,
+                    )
+                    if stderr_lines > 0:
+                        result += tr(
+                            "stderr_file: {stderr_file} (lines: {stderr_lines})\n",
+                            stderr_file=stderr_file.name,
+                            stderr_lines=stderr_lines,
+                        )
+                    result += tr(
+                        "returncode: {return_code}\nUse the view_file tool to inspect the contents of these files when needed.",
+                        return_code=return_code,
+                    )
+                    return result
+        except Exception as e:
+            self.report_error(tr(" ❌ Error: {error}", error=e), ReportAction.EXECUTE)
+            return tr("Error running command: {error}", error=e)