ripperdoc 0.2.9__py3-none-any.whl → 0.2.10__py3-none-any.whl

ripperdoc/tools/file_edit_tool.py

@@ -3,9 +3,11 @@
 Allows the AI to edit files by replacing text.
 """
 
+import contextlib
 import os
+import tempfile
 from pathlib import Path
-from typing import AsyncGenerator, List, Optional
+from typing import AsyncGenerator, Generator, List, Optional, TextIO
 from pydantic import BaseModel, Field
 
 from ripperdoc.core.tool import (
@@ -20,9 +22,42 @@ from ripperdoc.utils.log import get_logger
 from ripperdoc.utils.file_watch import record_snapshot
 from ripperdoc.utils.path_ignore import check_path_for_tool
 
+# Import fcntl for file locking on Unix systems
+try:
+    import fcntl
+
+    HAS_FCNTL = True
+except ImportError:
+    HAS_FCNTL = False
+
 logger = get_logger()
 
 
+@contextlib.contextmanager
+def _file_lock(file_handle: TextIO, exclusive: bool = True) -> Generator[None, None, None]:
+    """Acquire a file lock, with fallback for systems without fcntl.
+
+    Args:
+        file_handle: An open file handle to lock
+        exclusive: If True, acquire exclusive lock; otherwise shared lock
+
+    Yields:
+        None
+    """
+    if not HAS_FCNTL:
+        # On Windows or systems without fcntl, skip locking
+        yield
+        return
+
+    lock_type = fcntl.LOCK_EX if exclusive else fcntl.LOCK_SH
+    try:
+        fcntl.flock(file_handle.fileno(), lock_type)
+        yield
+    finally:
+        with contextlib.suppress(OSError):
+            fcntl.flock(file_handle.fileno(), fcntl.LOCK_UN)
+
+
 class FileEditToolInput(BaseModel):
     """Input schema for FileEditTool."""
 
@@ -180,57 +215,131 @@ match exactly (including whitespace and indentation)."""
     async def call(
         self, input_data: FileEditToolInput, context: ToolUseContext
     ) -> AsyncGenerator[ToolOutput, None]:
-        """Edit the file."""
+        """Edit the file with TOCTOU protection."""
+
+        abs_file_path = os.path.abspath(input_data.file_path)
+        file_state_cache = getattr(context, "file_state_cache", {})
+        file_snapshot = file_state_cache.get(abs_file_path)
 
         try:
-            # Read the file
-            with open(input_data.file_path, "r", encoding="utf-8") as f:
-                content = f.read()
-
-            # Check if old_string exists
-            if input_data.old_string not in content:
-                output = FileEditToolOutput(
-                    file_path=input_data.file_path,
-                    replacements_made=0,
-                    success=False,
-                    message=f"String not found in file: {input_data.file_path}",
-                )
-                yield ToolResult(
-                    data=output, result_for_assistant=self.render_result_for_assistant(output)
-                )
-                return
-
-            # Count occurrences
-            occurrence_count = content.count(input_data.old_string)
-
-            # Check for ambiguity if not replace_all
-            if not input_data.replace_all and occurrence_count > 1:
-                output = FileEditToolOutput(
-                    file_path=input_data.file_path,
-                    replacements_made=0,
-                    success=False,
-                    message=f"String appears {occurrence_count} times in file. "
-                    f"Either provide a unique string or use replace_all=true",
-                )
-                yield ToolResult(
-                    data=output, result_for_assistant=self.render_result_for_assistant(output)
-                )
-                return
-
-            # Perform replacement
-            if input_data.replace_all:
-                new_content = content.replace(input_data.old_string, input_data.new_string)
-                replacements = occurrence_count
-            else:
-                new_content = content.replace(input_data.old_string, input_data.new_string, 1)
-                replacements = 1
-
-            # Write the file
-            with open(input_data.file_path, "w", encoding="utf-8") as f:
-                f.write(new_content)
-
-            # Use absolute path to ensure consistency with validation lookup
-            abs_file_path = os.path.abspath(input_data.file_path)
+            # Open file with exclusive lock to prevent concurrent modifications
+            # Use r+ mode to get a file handle we can lock before reading
+            with open(abs_file_path, "r+", encoding="utf-8") as f:
+                with _file_lock(f, exclusive=True):
+                    # Re-check mtime AFTER acquiring lock to close TOCTOU window
+                    # This is the key fix: validate mtime while holding the lock
+                    if file_snapshot:
+                        try:
+                            current_mtime = os.fstat(f.fileno()).st_mtime
+                            if current_mtime > file_snapshot.timestamp:
+                                output = FileEditToolOutput(
+                                    file_path=input_data.file_path,
+                                    replacements_made=0,
+                                    success=False,
+                                    message="File has been modified since read, either by the user "
+                                    "or by a linter. Read it again before attempting to edit it.",
+                                )
+                                yield ToolResult(
+                                    data=output,
+                                    result_for_assistant=self.render_result_for_assistant(output),
+                                )
+                                return
+                        except OSError:
+                            pass  # fstat failed, proceed anyway
+
+                    # Read content while holding the lock
+                    content = f.read()
+
+                    # Check if old_string exists
+                    if input_data.old_string not in content:
+                        output = FileEditToolOutput(
+                            file_path=input_data.file_path,
+                            replacements_made=0,
+                            success=False,
+                            message=f"String not found in file: {input_data.file_path}",
+                        )
+                        yield ToolResult(
+                            data=output,
+                            result_for_assistant=self.render_result_for_assistant(output),
+                        )
+                        return
+
+                    # Count occurrences
+                    occurrence_count = content.count(input_data.old_string)
+
+                    # Check for ambiguity if not replace_all
+                    if not input_data.replace_all and occurrence_count > 1:
+                        output = FileEditToolOutput(
+                            file_path=input_data.file_path,
+                            replacements_made=0,
+                            success=False,
+                            message=f"String appears {occurrence_count} times in file. "
+                            f"Either provide a unique string or use replace_all=true",
+                        )
+                        yield ToolResult(
+                            data=output,
+                            result_for_assistant=self.render_result_for_assistant(output),
+                        )
+                        return
+
+                    # Perform replacement
+                    if input_data.replace_all:
+                        new_content = content.replace(input_data.old_string, input_data.new_string)
+                        replacements = occurrence_count
+                    else:
+                        new_content = content.replace(
+                            input_data.old_string, input_data.new_string, 1
+                        )
+                        replacements = 1
+
+                    # Atomic write: write to temp file then rename
+                    # This ensures the file is either fully written or not at all
+                    file_dir = os.path.dirname(abs_file_path)
+                    try:
+                        # Create temp file in same directory to ensure same filesystem
+                        fd, temp_path = tempfile.mkstemp(
+                            dir=file_dir, prefix=".ripperdoc_edit_", suffix=".tmp"
+                        )
+                        try:
+                            with os.fdopen(fd, "w", encoding="utf-8") as temp_f:
+                                temp_f.write(new_content)
+                            # Preserve original file permissions
+                            original_stat = os.fstat(f.fileno())
+                            os.chmod(temp_path, original_stat.st_mode)
+                            # Atomic replace (works on Unix, best-effort on Windows)
+                            os.replace(temp_path, abs_file_path)
+                        except Exception:
+                            # Clean up temp file on failure
+                            with contextlib.suppress(OSError):
+                                os.unlink(temp_path)
+                            raise
+                    except OSError as atomic_error:
+                        # Fallback to in-place write if atomic write fails
+                        # (e.g., cross-filesystem issues)
+                        # Re-verify file hasn't changed before fallback write (TOCTOU protection)
+                        f.seek(0)
+                        current_content = f.read()
+                        if current_content != content:
+                            output = FileEditToolOutput(
+                                file_path=input_data.file_path,
+                                replacements_made=0,
+                                success=False,
+                                message="File was modified during atomic write fallback. Please retry.",
+                            )
+                            yield ToolResult(
+                                data=output,
+                                result_for_assistant=self.render_result_for_assistant(output),
+                            )
+                            return
+                        f.seek(0)
+                        f.truncate()
+                        f.write(new_content)
+                        logger.debug(
+                            "[file_edit_tool] Atomic write failed, used fallback: %s",
+                            atomic_error,
+                        )
+
+            # Record the new snapshot after successful edit
             try:
                 record_snapshot(
                     abs_file_path,

ripperdoc/tools/file_read_tool.py

@@ -22,6 +22,10 @@ from ripperdoc.utils.path_ignore import check_path_for_tool
 
 logger = get_logger()
 
+# Maximum file size to read (default 50MB, configurable via env)
+MAX_FILE_SIZE_MB = float(os.getenv("RIPPERDOC_MAX_READ_FILE_SIZE_MB", "50"))
+MAX_FILE_SIZE_BYTES = int(MAX_FILE_SIZE_MB * 1024 * 1024)
+
 
 class FileReadToolInput(BaseModel):
     """Input schema for FileReadTool."""
@@ -140,6 +144,22 @@ and limit to read only a portion of the file."""
         """Read the file."""
 
         try:
+            # Check file size before reading to prevent memory exhaustion
+            file_size = os.path.getsize(input_data.file_path)
+            if file_size > MAX_FILE_SIZE_BYTES:
+                error_output = FileReadToolOutput(
+                    content=f"File too large to read: {file_size / (1024*1024):.1f}MB exceeds limit of {MAX_FILE_SIZE_MB}MB. Use offset and limit parameters to read portions.",
+                    file_path=input_data.file_path,
+                    line_count=0,
+                    offset=0,
+                    limit=None,
+                )
+                yield ToolResult(
+                    data=error_output,
+                    result_for_assistant=f"Error: File {input_data.file_path} is too large ({file_size / (1024*1024):.1f}MB). Maximum size is {MAX_FILE_SIZE_MB}MB. Use offset and limit to read portions.",
+                )
+                return
+
             with open(input_data.file_path, "r", encoding="utf-8", errors="replace") as f:
                 lines = f.readlines()
 

ripperdoc/tools/file_write_tool.py

@@ -104,6 +104,13 @@ NEVER write new files unless explicitly required by the user."""
 
         file_path = os.path.abspath(input_data.file_path)
 
+        file_path_obj = Path(file_path)
+        should_proceed, warning_msg = check_path_for_tool(
+            file_path_obj, tool_name="Write", warn_only=True
+        )
+        if warning_msg:
+            logger.warning("[file_write_tool] %s", warning_msg)
+
         # If file doesn't exist, it's a new file - allow without reading first
         if not os.path.exists(file_path):
             return ValidationResult(result=True)
@@ -132,14 +139,6 @@ NEVER write new files unless explicitly required by the user."""
         except OSError:
             pass  # File mtime check failed, proceed anyway
 
-        # Check if path is ignored (warning for write operations)
-        file_path_obj = Path(file_path)
-        should_proceed, warning_msg = check_path_for_tool(
-            file_path_obj, tool_name="Write", warn_only=True
-        )
-        if warning_msg:
-            logger.warning("[file_write_tool] %s", warning_msg)
-
         return ValidationResult(result=True)
 
     def render_result_for_assistant(self, output: FileWriteToolOutput) -> str: