quantalogic 0.59.2__py3-none-any.whl → 0.60.0__py3-none-any.whl

quantalogic/tools/execute_bash_command_tool.py

@@ -6,6 +6,10 @@ import signal
 import subprocess
 import sys
 from typing import Dict, Optional, Union
+from pathlib import Path
+from datetime import datetime
+import shutil
+import re
 
 from loguru import logger
 
@@ -24,7 +28,7 @@ class ExecuteBashCommandTool(Tool):
     """Tool for executing bash commands with real-time I/O handling."""
 
     name: str = "execute_bash_tool"
-    description: str = "Executes a bash command and returns its output."
+    description: str = "Executes a bash command and returns its output. All commands are executed in /tmp for security."
     need_validation: bool = True
     arguments: list = [
         ToolArgument(
@@ -34,14 +38,6 @@ class ExecuteBashCommandTool(Tool):
             required=True,
             example="ls -la",
         ),
-        ToolArgument(
-            name="working_dir",
-            arg_type="string",
-            description="The working directory where the command will be executed. Defaults to the current directory.",
-            required=False,
-            example="/path/to/directory",
-            default=os.getcwd(),
-        ),
         ToolArgument(
             name="timeout",
             arg_type="int",
@@ -52,15 +48,67 @@ class ExecuteBashCommandTool(Tool):
         ),
     ]
 
+    def _validate_command(self, command: str) -> None:
+        """Validate the command for potential security risks."""
+        forbidden_commands = ["rm -rf /", "mkfs", "dd", ":(){ :|:& };:"]
+        for cmd in forbidden_commands:
+            if cmd in command.lower():
+                raise ValueError(f"Command '{command}' contains forbidden operation")
+
+    def _handle_mkdir_command(self, command: str) -> str:
+        """Handle mkdir command with automatic cleanup and date suffix.
+        
+        Args:
+            command: The original mkdir command
+            
+        Returns:
+            Modified command that handles existing directories and adds date suffix
+        """
+        try:
+            # Extract directory name from mkdir command
+            mkdir_pattern = r'mkdir\s+(?:-p\s+)?["\']?([^"\'>\n]+)["\']?'
+            match = re.search(mkdir_pattern, command)
+            if not match:
+                return command
+                
+            dir_name = match.group(1)
+            # Add timestamp suffix
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            new_dir_name = f"{dir_name}_{timestamp}"
+            
+            # Create cleanup and mkdir commands
+            cleanup_cmd = f'rm -rf "{dir_name}" 2>/dev/null; '
+            mkdir_cmd = command.replace(dir_name, new_dir_name)
+            
+            return cleanup_cmd + mkdir_cmd
+            
+        except Exception as e:
+            logger.warning(f"Error processing mkdir command: {e}")
+            return command
+
+    def _format_output(self, stdout: str, return_code: int, error: Optional[str] = None) -> str:
+        """Format command output with stdout, return code, and optional error."""
+        formatted_result = "<command_output>\n"
+        formatted_result += f" <stdout>{stdout.strip()}</stdout>\n"
+        formatted_result += f" <returncode>{return_code}</returncode>\n"
+        if error:
+            formatted_result += f" <error>{error}</error>\n"
+        formatted_result += "</command_output>"
+        return formatted_result
+
     def _execute_windows(
         self,
         command: str,
-        cwd: str,
         timeout_seconds: int,
         env_vars: Dict[str, str],
+        cwd: Optional[str] = None,
     ) -> str:
         """Execute command on Windows platform."""
         try:
+            # Handle mkdir commands
+            if "mkdir" in command:
+                command = self._handle_mkdir_command(command)
+
             # On Windows, use subprocess with pipes
             process = subprocess.Popen(
                 command,
@@ -68,7 +116,7 @@ class ExecuteBashCommandTool(Tool):
                 stdin=subprocess.PIPE,
                 stdout=subprocess.PIPE,
                 stderr=subprocess.PIPE,
-                cwd=cwd,
+                cwd="/tmp",  # cwd, Force /tmp directory
                 env=env_vars,
                 text=True,
                 encoding="utf-8",
@@ -77,34 +125,27 @@ class ExecuteBashCommandTool(Tool):
             try:
                 stdout, stderr = process.communicate(timeout=timeout_seconds)
                 return_code = process.returncode
-
-                if return_code != 0 and stderr:
-                    logger.warning(f"Command failed with error: {stderr}")
-
-                formatted_result = (
-                    "<command_output>"
-                    f" <stdout>{stdout.strip()}</stdout>"
-                    f" <returncode>{return_code}</returncode>"
-                    f"</command_output>"
-                )
-                return formatted_result
+                return self._format_output(stdout, return_code, stderr if stderr else None)
 
             except subprocess.TimeoutExpired:
                 process.kill()
-                return f"Command timed out after {timeout_seconds} seconds."
+                return self._format_output("", 1, f"Command timed out after {timeout_seconds} seconds")
 
         except Exception as e:
-            return f"Unexpected error executing command: {str(e)}"
+            return self._format_output("", 1, f"Unexpected error executing command: {str(e)}")
 
     def _execute_unix(
         self,
         command: str,
-        cwd: str,
         timeout_seconds: int,
         env_vars: Dict[str, str],
     ) -> str:
         """Execute command on Unix platform."""
         try:
+            # Handle mkdir commands
+            if "mkdir" in command:
+                command = self._handle_mkdir_command(command)
+
             master, slave = pty.openpty()
             proc = subprocess.Popen(
                 command,
@@ -112,7 +153,7 @@ class ExecuteBashCommandTool(Tool):
                 stdin=slave,
                 stdout=slave,
                 stderr=subprocess.STDOUT,
-                cwd=cwd,
+                cwd="/tmp",                # cwd=cwd, # Force /tmp directory
                 env=env_vars,
                 preexec_fn=os.setsid,
                 close_fds=True,
@@ -127,74 +168,90 @@ class ExecuteBashCommandTool(Tool):
                     rlist, _, _ = select.select([master, sys.stdin], [], [], timeout_seconds)
                     if not rlist:
                         if proc.poll() is not None:
-                            break  # Process completed but select timed out
+                            break
                         raise subprocess.TimeoutExpired(command, timeout_seconds)
 
                     for fd in rlist:
                         if fd == master:
-                            data = os.read(master, 1024).decode()
-                            if not data:
+                            try:
+                                data = os.read(master, 1024).decode()
+                                if not data:
+                                    break_loop = True
+                                    break
+                                stdout_buffer.append(data)
+                                sys.stdout.write(data)
+                                sys.stdout.flush()
+                            except (OSError, UnicodeDecodeError) as e:
+                                logger.warning(f"Error reading output: {e}")
                                 break_loop = True
                                 break
-                            stdout_buffer.append(data)
-                            sys.stdout.write(data)
-                            sys.stdout.flush()
                         elif fd == sys.stdin:
-                            user_input = os.read(sys.stdin.fileno(), 1024)
-                            os.write(master, user_input)
+                            try:
+                                user_input = os.read(sys.stdin.fileno(), 1024)
+                                os.write(master, user_input)
+                            except OSError as e:
+                                logger.warning(f"Error handling input: {e}")
 
                     if break_loop or proc.poll() is not None:
-                        while True:
-                            data = os.read(master, 1024).decode()
-                            if not data:
-                                break
-                            stdout_buffer.append(data)
-                            sys.stdout.write(data)
-                            sys.stdout.flush()
+                        try:
+                            while True:
+                                data = os.read(master, 1024).decode()
+                                if not data:
+                                    break
+                                stdout_buffer.append(data)
+                                sys.stdout.write(data)
+                                sys.stdout.flush()
+                        except (OSError, UnicodeDecodeError):
+                            pass
                         break
 
             except subprocess.TimeoutExpired:
                 os.killpg(os.getpgid(proc.pid), signal.SIGTERM)
-                return f"Command timed out after {timeout_seconds} seconds."
+                return self._format_output("", 1, f"Command timed out after {timeout_seconds} seconds")
             except EOFError:
-                pass  # Process exited normally
+                pass
             finally:
                 os.close(master)
                 proc.wait()
 
             stdout_content = "".join(stdout_buffer)
             return_code = proc.returncode
-            formatted_result = (
-                "<command_output>"
-                f" <stdout>{stdout_content.strip()}</stdout>"
-                f" <returncode>{return_code}</returncode>"
-                f"</command_output>"
-            )
-            return formatted_result
+            return self._format_output(stdout_content, return_code)
+
         except Exception as e:
-            return f"Unexpected error executing command: {str(e)}"
+            return self._format_output("", 1, f"Unexpected error executing command: {str(e)}")
 
     def execute(
         self,
         command: str,
-        working_dir: Optional[str] = None,
+        working_dir: Optional[str] = None,  # Kept for backward compatibility but ignored
         timeout: Union[int, str, None] = 60,
         env: Optional[Dict[str, str]] = None,
     ) -> str:
-        """Executes a bash command with interactive input handling."""
+        """Executes a bash command with interactive input handling in /tmp directory."""
+        # Ensure /tmp exists and is writable
+        tmp_dir = Path("/tmp")
+        if not (tmp_dir.exists() and os.access(tmp_dir, os.W_OK)):
+            return self._format_output("", 1, "Error: /tmp directory is not accessible")
+
+        # Validate command
+        try:
+            self._validate_command(command)
+        except ValueError as e:
+            return self._format_output("", 1, str(e))
+
         timeout_seconds = int(timeout) if timeout else 60
-        cwd = working_dir or os.getcwd()
         env_vars = os.environ.copy()
         if env:
             env_vars.update(env)
 
         if sys.platform == "win32":
-            return self._execute_windows(command, cwd, timeout_seconds, env_vars)
+            return self._execute_windows(command, timeout_seconds, env_vars)
         else:
             if not pty:
                 logger.warning("PTY module not available, falling back to Windows-style execution")
-                return self._execute_windows(command, cwd, timeout_seconds, env_vars)
-            return self._execute_unix(command, cwd, timeout_seconds, env_vars)
+                return self._execute_windows(command, timeout_seconds, env_vars)
+            return self._execute_unix(command, timeout_seconds, env_vars)
 
 
 if __name__ == "__main__":

quantalogic/tools/file_tracker_tool.py

@@ -0,0 +1,49 @@
+"""Tool for tracking and returning paths of files created during a process."""
+
+from typing import List
+from pydantic import Field
+
+from quantalogic.tools.tool import Tool, ToolArgument
+
+
+class FileTrackerTool(Tool):
+    """Tool for tracking and returning file paths created during a process.""" 
+    name: str = "file_tracker_tool"
+    description: str = "Tracks and returns file paths created during a process."
+    need_validation: bool = False
+    arguments: list = [
+        ToolArgument(
+            name="file_path",
+            arg_type="string",
+            description="The path to the file to write. Using an absolute path is recommended.",
+            required=True,
+            example="/path/to/file.txt",
+        ),
+        ToolArgument(
+            name="content",
+            arg_type="string",
+            description="""
+            The content to write to the file. Use CDATA to escape special characters.
+            Don't add newlines at the beginning or end of the content.
+            """,
+            required=True,
+            example="Hello, world!",
+        ),
+        ToolArgument(
+            name="append_mode",
+            arg_type="string",
+            description="""Append mode. If true, the content will be appended to the end of the file.
+            """,
+            required=False,
+            example="False",
+        ),
+        ToolArgument(
+            name="overwrite",
+            arg_type="string",
+            description="Overwrite mode. If true, existing files can be overwritten. Defaults to False.",
+            required=False,
+            example="False",
+            default="False",
+        ),
+    ]
+    execute = lambda self, file_path: file_path

quantalogic/tools/google_packages/google_news_tool.py

@@ -95,6 +95,7 @@ class GoogleNewsTool(Tool):
     """
 
     name: str = "google_news_tool"
+    need_post_process: bool = False
     description: str = (
         "Advanced news retrieval and analysis tool with support for sentiment analysis, "
         "keyword extraction, and article summarization."
@@ -295,6 +296,8 @@ class GoogleNewsTool(Tool):
                 }
                 processed_articles.append(processed_article)
 
+
+            logger.info(f"Fetched {len(processed_articles)} articles for query: {query}")
             # Return pretty-printed JSON string, matching DuckDuckGo tool format
             return json.dumps(processed_articles, indent=4, ensure_ascii=False)