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

ripperdoc/tools/background_shell.py

@@ -14,7 +14,7 @@ import time
 import uuid
 import weakref
 from dataclasses import dataclass, field
-from typing import Any, Dict, List, Optional
+from typing import Any, Callable, Dict, List, Optional
 
 import atexit
 
@@ -34,6 +34,7 @@ class BackgroundTask:
     process: asyncio.subprocess.Process
     start_time: float
     timeout: Optional[float] = None
+    end_time: Optional[float] = None
     stdout_chunks: List[str] = field(default_factory=list)
     stderr_chunks: List[str] = field(default_factory=list)
     exit_code: Optional[int] = None
@@ -41,6 +42,7 @@ class BackgroundTask:
     timed_out: bool = False
     reader_tasks: List[asyncio.Task] = field(default_factory=list)
     done_event: asyncio.Event = field(default_factory=asyncio.Event)
+    completion_callbacks: List[Callable[["BackgroundTask"], None]] = field(default_factory=list)
 
 
 DEFAULT_TASK_TTL_SEC = float(os.getenv("RIPPERDOC_BASH_TASK_TTL_SEC", "3600"))
@@ -251,6 +253,7 @@ class BackgroundShellManager:
                     with contextlib.suppress(asyncio.TimeoutError, ProcessLookupError):
                         await asyncio.wait_for(task.process.wait(), timeout=kill_timeout)
                 task.exit_code = task.process.returncode or -1
+                task.end_time = task.end_time or _loop_time()
             except (OSError, RuntimeError, asyncio.CancelledError) as exc:
                 if not isinstance(exc, asyncio.CancelledError):
                     _safe_log_exception(
@@ -261,6 +264,7 @@ class BackgroundShellManager:
             finally:
                 await _finalize_reader_tasks(task.reader_tasks, timeout=0.3 if force else 1.0)
                 task.done_event.set()
+                _run_completion_callbacks(task)
 
         current = asyncio.current_task()
         pending = [t for t in asyncio.all_tasks(loop) if t is not current]
@@ -277,6 +281,7 @@ class BackgroundShellManager:
 # Module-level functions that delegate to the singleton manager
 # These maintain backward compatibility with existing code
 
+
 def _get_manager() -> BackgroundShellManager:
     """Get the singleton manager instance."""
     return BackgroundShellManager.get_instance()
@@ -346,6 +351,21 @@ async def _finalize_reader_tasks(reader_tasks: List[asyncio.Task], timeout: floa
         await asyncio.gather(*reader_tasks, return_exceptions=True)
 
 
+def _run_completion_callbacks(task: BackgroundTask) -> None:
+    """Invoke completion callbacks safely for a finished task."""
+    if not task.completion_callbacks:
+        return
+    for callback in list(task.completion_callbacks):
+        try:
+            callback(task)
+        except Exception:
+            logger.debug(
+                "Background task completion callback failed",
+                exc_info=True,
+                extra={"task_id": task.id, "command": task.command},
+            )
+
+
 async def _monitor_task(task: BackgroundTask) -> None:
     """Wait for a background process to finish or timeout, then mark status."""
     try:
@@ -355,6 +375,7 @@ async def _monitor_task(task: BackgroundTask) -> None:
             await task.process.wait()
         with _get_tasks_lock():
             task.exit_code = task.process.returncode
+            task.end_time = task.end_time or _loop_time()
     except asyncio.TimeoutError:
         logger.warning(f"Background task {task.id} timed out after {task.timeout}s: {task.command}")
         with _get_tasks_lock():
@@ -363,6 +384,7 @@ async def _monitor_task(task: BackgroundTask) -> None:
         await task.process.wait()
         with _get_tasks_lock():
             task.exit_code = -1
+            task.end_time = task.end_time or _loop_time()
     except asyncio.CancelledError:
         return
     except (OSError, RuntimeError, ProcessLookupError) as exc:
@@ -374,14 +396,19 @@ async def _monitor_task(task: BackgroundTask) -> None:
         )
         with _get_tasks_lock():
             task.exit_code = -1
+            task.end_time = task.end_time or _loop_time()
     finally:
         # Ensure readers are finished before marking done.
         await _finalize_reader_tasks(task.reader_tasks)
         task.done_event.set()
+        _run_completion_callbacks(task)
 
 
 async def _start_background_command(
-    command: str, timeout: Optional[float] = None, shell_executable: Optional[str] = None
+    command: str,
+    timeout: Optional[float] = None,
+    shell_executable: Optional[str] = None,
+    completion_callbacks: Optional[List[Callable[["BackgroundTask"], None]]] = None,
 ) -> str:
     """Launch a background shell command on the dedicated loop."""
     selected_shell = shell_executable or find_suitable_shell()
@@ -401,6 +428,7 @@ async def _start_background_command(
         process=process,
         start_time=_loop_time(),
         timeout=timeout,
+        completion_callbacks=list(completion_callbacks or []),
     )
     with _get_tasks_lock():
         _get_tasks()[task_id] = record
@@ -420,11 +448,16 @@ async def _start_background_command(
 
 
 async def start_background_command(
-    command: str, timeout: Optional[float] = None, shell_executable: Optional[str] = None
+    command: str,
+    timeout: Optional[float] = None,
+    shell_executable: Optional[str] = None,
+    completion_callbacks: Optional[List[Callable[["BackgroundTask"], None]]] = None,
 ) -> str:
     """Launch a background shell command and return its task id."""
     future = _submit_to_background_loop(
-        _start_background_command(command, timeout, shell_executable)
+        _start_background_command(
+            command, timeout, shell_executable, completion_callbacks=completion_callbacks
+        )
     )
     return await asyncio.wrap_future(future)
 
@@ -453,6 +486,7 @@ def get_background_status(task_id: str, consume: bool = True) -> dict:
 
     If consume is True, buffered stdout/stderr are cleared after reading.
     """
+    now = _loop_time()
     tasks = _get_tasks()
     with _get_tasks_lock():
         if task_id not in tasks:
@@ -462,6 +496,14 @@ def get_background_status(task_id: str, consume: bool = True) -> dict:
         stdout = "".join(task.stdout_chunks)
         stderr = "".join(task.stderr_chunks)
 
+        finished = task.exit_code is not None or task.killed or task.timed_out
+        if finished and task.end_time is None:
+            task.end_time = now
+        duration_ms = (
+            ((task.end_time or now) - task.start_time) * 1000.0 if task.start_time else None
+        )
+        age_ms = (now - task.start_time) * 1000.0 if task.start_time else None
+
         if consume:
             task.stdout_chunks.clear()
             task.stderr_chunks.clear()
@@ -475,7 +517,8 @@ def get_background_status(task_id: str, consume: bool = True) -> dict:
             "exit_code": task.exit_code,
             "timed_out": task.timed_out,
             "killed": task.killed,
-            "duration_ms": (_loop_time() - task.start_time) * 1000.0,
+            "duration_ms": duration_ms,
+            "age_ms": age_ms,
         }
 
 
@@ -506,6 +549,7 @@ async def kill_background_task(task_id: str) -> bool:
 
             with _get_tasks_lock():
                 task.exit_code = task.process.returncode or -1
+                task.end_time = task.end_time or _loop_time()
             return True
         finally:
             await _finalize_reader_tasks(task.reader_tasks)

ripperdoc/tools/bash_tool.py

@@ -50,6 +50,7 @@ from ripperdoc.utils.sandbox_utils import create_sandbox_wrapper, is_sandbox_ava
 from ripperdoc.utils.safe_get_cwd import get_original_cwd, safe_get_cwd
 from ripperdoc.utils.shell_utils import build_shell_command, find_suitable_shell
 from ripperdoc.utils.log import get_logger
+from ripperdoc.utils.platform import IS_WINDOWS
 
 logger = get_logger()
 
@@ -597,6 +598,7 @@ build projects, run tests, and interact with the file system."""
         sandbox_requested: bool,
         start_time: float,
         input_data: BashToolInput,
+        context: Optional[ToolUseContext] = None,
     ) -> Optional[BashToolOutput]:
         """Run a command in background mode.
 
@@ -622,8 +624,50 @@ build projects, run tests, and interact with the file system."""
             if input_data.timeout is None
             else (timeout_seconds if timeout_seconds > 0 else None)
         )
+
+        completion_callbacks = None
+        queue = getattr(context, "pending_message_queue", None) if context else None
+        if queue is not None:
+
+            def _notify_completion(task: Any) -> None:
+                # Mirror status computation from background_shell._compute_status
+                if getattr(task, "killed", False):
+                    status = "killed"
+                elif getattr(task, "timed_out", False):
+                    status = "failed"
+                else:
+                    exit_code = getattr(task, "exit_code", None)
+                    status = (
+                        "running"
+                        if exit_code is None
+                        else ("completed" if exit_code == 0 else "failed")
+                    )
+                exit_code = getattr(task, "exit_code", None)
+                status_line = (
+                    f"Background bash task {getattr(task, 'id', '')} finished with status: {status}"
+                )
+                if exit_code is not None:
+                    status_line += f" (exit code {exit_code})"
+                details = [
+                    status_line,
+                    f"Command: {effective_command}",
+                    "Use BashOutput with this task id to read stdout/stderr and continue.",
+                ]
+                queue.enqueue_text(
+                    "\n".join(details),
+                    metadata={
+                        "source": "background_bash",
+                        "background_task_id": getattr(task, "id", None),
+                    },
+                )
+
+            completion_callbacks = [_notify_completion]  # type: ignore[assignment]
+
         task_id = await start_background_command(
-            final_command, timeout=bg_timeout, shell_executable=resolved_shell
+            final_command,
+            timeout=bg_timeout,
+            shell_executable=resolved_shell,
+            completion_callbacks=completion_callbacks,  # type: ignore[arg-type]
         )
 
         return BashToolOutput(
@@ -889,6 +933,7 @@ build projects, run tests, and interact with the file system."""
                     sandbox_requested,
                     start,
                     input_data,
+                    context,
                 )
                 if output:
                     yield ToolResult(
@@ -1021,35 +1066,56 @@ build projects, run tests, and interact with the file system."""
         finally:
             self._current_is_read_only = previous_read_only
             if sandbox_cleanup:
-                with contextlib.suppress(Exception):
+                with contextlib.suppress(OSError, IOError, PermissionError):
                     sandbox_cleanup()
 
     async def _force_kill_process(
         self, process: asyncio.subprocess.Process, grace_seconds: float = KILL_GRACE_SECONDS
     ) -> None:
-        """Attempt to terminate a process group and avoid hanging waits."""
+        """Attempt to terminate a process group and avoid hanging waits.
+
+        Platform differences:
+        - Unix: Uses killpg with SIGTERM/SIGKILL to terminate process groups
+        - Windows: Uses process.terminate()/kill() which sends appropriate signals
+        """
         if process.returncode is not None:
             return
 
         def _terminate() -> None:
-            if hasattr(os, "killpg"):
-                os.killpg(process.pid, signal.SIGTERM)
+            if IS_WINDOWS:
+                # Windows: use process.terminate() which is cross-platform
+                process.terminate()
+            elif hasattr(os, "killpg"):
+                # Unix: terminate the entire process group
+                try:
+                    os.killpg(process.pid, signal.SIGTERM)
+                except (ProcessLookupError, PermissionError, OSError):
+                    # Fallback to single process termination
+                    process.terminate()
             else:
                 process.terminate()
 
         def _kill() -> None:
-            if hasattr(os, "killpg"):
-                os.killpg(process.pid, signal.SIGKILL)
+            if IS_WINDOWS:
+                # Windows: use process.kill() which forcefully terminates
+                process.kill()
+            elif hasattr(os, "killpg") and hasattr(signal, "SIGKILL"):
+                # Unix: forcefully kill the entire process group
+                try:
+                    os.killpg(process.pid, signal.SIGKILL)
+                except (ProcessLookupError, PermissionError, OSError):
+                    # Fallback to single process kill
+                    process.kill()
             else:
                 process.kill()
 
-        with contextlib.suppress(ProcessLookupError, PermissionError):
+        with contextlib.suppress(ProcessLookupError, PermissionError, OSError):
             _terminate()
         with contextlib.suppress(asyncio.TimeoutError):
             await asyncio.wait_for(process.wait(), timeout=grace_seconds)
             return
 
-        with contextlib.suppress(ProcessLookupError, PermissionError):
+        with contextlib.suppress(ProcessLookupError, PermissionError, OSError):
             _kill()
         with contextlib.suppress(asyncio.TimeoutError):
             await asyncio.wait_for(process.wait(), timeout=grace_seconds)

ripperdoc/tools/file_edit_tool.py

@@ -19,18 +19,36 @@ from ripperdoc.core.tool import (
     ValidationResult,
 )
 from ripperdoc.utils.log import get_logger
+from ripperdoc.utils.platform import HAS_FCNTL
 from ripperdoc.utils.file_watch import record_snapshot
 from ripperdoc.utils.path_ignore import check_path_for_tool
+from ripperdoc.tools.file_read_tool import detect_file_encoding
 
-# Import fcntl for file locking on Unix systems
-try:
-    import fcntl
+logger = get_logger()
 
-    HAS_FCNTL = True
-except ImportError:
-    HAS_FCNTL = False
 
-logger = get_logger()
+def determine_edit_encoding(file_path: str, new_content: str) -> str:
+    """Determine encoding for editing a file.
+
+    Detects the file's current encoding and verifies the new content
+    can be encoded with it. Falls back to UTF-8 if needed.
+    """
+    detected_encoding, _ = detect_file_encoding(file_path)
+
+    if not detected_encoding:
+        return "utf-8"
+
+    # Verify new content can be encoded
+    try:
+        new_content.encode(detected_encoding)
+        return detected_encoding
+    except (UnicodeEncodeError, LookupError):
+        logger.info(
+            "New content cannot be encoded with %s, falling back to UTF-8 for %s",
+            detected_encoding,
+            file_path,
+        )
+        return "utf-8"
 
 
 @contextlib.contextmanager
@@ -49,6 +67,8 @@ def _file_lock(file_handle: TextIO, exclusive: bool = True) -> Generator[None, N
         yield
         return
 
+    import fcntl
+
     lock_type = fcntl.LOCK_EX if exclusive else fcntl.LOCK_SH
     try:
         fcntl.flock(file_handle.fileno(), lock_type)
@@ -221,31 +241,66 @@ match exactly (including whitespace and indentation)."""
         file_state_cache = getattr(context, "file_state_cache", {})
         file_snapshot = file_state_cache.get(abs_file_path)
 
+        # Detect file encoding before opening
+        file_encoding, _ = detect_file_encoding(abs_file_path)
+        if not file_encoding:
+            file_encoding = "utf-8"
+
         try:
             # 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:
+            #
+            # TOCTOU mitigation strategy:
+            # 1. Record mtime immediately after open (pre_lock_mtime)
+            # 2. Acquire exclusive lock
+            # 3. Check mtime again after lock (post_lock_mtime)
+            # 4. If pre != post, file was modified in the window between open and lock
+            # 5. Also validate against cached snapshot timestamp
+            with open(abs_file_path, "r+", encoding=file_encoding) as f:
+                # Record mtime immediately after open, before acquiring lock
+                try:
+                    pre_lock_mtime = os.fstat(f.fileno()).st_mtime
+                except OSError:
+                    pre_lock_mtime = None
+
                 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
+                    # Check mtime after acquiring lock to detect modifications
+                    # during the window between open() and lock acquisition
+                    try:
+                        post_lock_mtime = os.fstat(f.fileno()).st_mtime
+                    except OSError:
+                        post_lock_mtime = None
+
+                    # Detect modification during open->lock window
+                    if pre_lock_mtime is not None and post_lock_mtime is not None:
+                        if post_lock_mtime > pre_lock_mtime:
+                            output = FileEditToolOutput(
+                                file_path=input_data.file_path,
+                                replacements_made=0,
+                                success=False,
+                                message="File was modified while acquiring lock. Please retry.",
+                            )
+                            yield ToolResult(
+                                data=output,
+                                result_for_assistant=self.render_result_for_assistant(output),
+                            )
+                            return
+
+                    # Validate against cached snapshot timestamp
+                    if file_snapshot and post_lock_mtime is not None:
+                        if post_lock_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
 
                     # Read content while holding the lock
                     content = f.read()
@@ -292,6 +347,19 @@ match exactly (including whitespace and indentation)."""
                         )
                         replacements = 1
 
+                    # Verify new content can be encoded with file's encoding
+                    # If not, fall back to UTF-8
+                    write_encoding = file_encoding
+                    try:
+                        new_content.encode(file_encoding)
+                    except (UnicodeEncodeError, LookupError):
+                        logger.info(
+                            "New content cannot be encoded with %s, using UTF-8 for %s",
+                            file_encoding,
+                            abs_file_path,
+                        )
+                        write_encoding = "utf-8"
+
                     # 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)
@@ -301,7 +369,7 @@ match exactly (including whitespace and indentation)."""
                             dir=file_dir, prefix=".ripperdoc_edit_", suffix=".tmp"
                         )
                         try:
-                            with os.fdopen(fd, "w", encoding="utf-8") as temp_f:
+                            with os.fdopen(fd, "w", encoding=write_encoding) as temp_f:
                                 temp_f.write(new_content)
                             # Preserve original file permissions
                             original_stat = os.fstat(f.fileno())
@@ -345,6 +413,7 @@ match exactly (including whitespace and indentation)."""
                     abs_file_path,
                     new_content,
                     getattr(context, "file_state_cache", {}),
+                    encoding=write_encoding,
                 )
             except (OSError, IOError, RuntimeError) as exc:
                 logger.warning(