feat: Implement file content update functionality and associated tests

- Added `update_file_content` method to `FileService` for updating existing file content in MinIO and updating metadata in Redis.
- Introduced `_update_mounted_files_content` method in `ExecutionOrchestrator` to handle in-place edits to mounted files after execution.
- Created integration tests in `test_mounted_file_edits.py` to verify persistence of edits to mounted files.
- Developed unit tests in `test_file_service.py` to ensure correct behavior of the `update_file_content` method, including success and error scenarios.

Author: usnavy13

src/services/file.py

@@ -804,6 +804,98 @@ async def update_file_state_hash(
             )
             return False
 
+    async def update_file_content(
+        self,
+        session_id: str,
+        file_id: str,
+        content: bytes,
+        state_hash: Optional[str] = None,
+        execution_id: Optional[str] = None,
+    ) -> bool:
+        """Update the content of an existing file.
+
+        Overwrites the MinIO object and updates metadata. Used to persist
+        in-place edits to mounted files after execution.
+
+        Args:
+            session_id: Session identifier
+            file_id: File identifier
+            content: New file content as bytes
+            state_hash: Optional SHA256 hash of the Python state
+            execution_id: Optional ID of the execution that modified this file
+
+        Returns:
+            True if update was successful
+        """
+        try:
+            # Get existing metadata to find object_key
+            metadata = await self._get_file_metadata(session_id, file_id)
+            if not metadata:
+                logger.warning(
+                    "File not found for content update",
+                    session_id=session_id[:12],
+                    file_id=file_id,
+                )
+                return False
+
+            object_key = metadata.get("object_key")
+            if not object_key:
+                logger.warning(
+                    "No object_key in file metadata",
+                    session_id=session_id[:12],
+                    file_id=file_id,
+                )
+                return False
+
+            # Overwrite content in MinIO
+            import io
+
+            loop = asyncio.get_event_loop()
+            content_stream = io.BytesIO(content)
+            content_type = metadata.get("content_type", "application/octet-stream")
+
+            await loop.run_in_executor(
+                None,
+                lambda: self.minio_client.put_object(
+                    self.bucket_name,
+                    object_key,
+                    content_stream,
+                    len(content),
+                    content_type,
+                ),
+            )
+
+            # Update metadata
+            now = datetime.utcnow().isoformat()
+            updates = {
+                "size": len(content),
+                "last_used_at": now,
+            }
+            if state_hash:
+                updates["state_hash"] = state_hash
+            if execution_id:
+                updates["execution_id"] = execution_id
+
+            metadata_key = self._get_file_metadata_key(session_id, file_id)
+            await self.redis_client.hset(metadata_key, mapping=updates)
+
+            logger.debug(
+                "Updated file content",
+                session_id=session_id[:12],
+                file_id=file_id,
+                size=len(content),
+            )
+            return True
+
+        except Exception as e:
+            logger.error(
+                "Failed to update file content",
+                error=str(e),
+                session_id=session_id,
+                file_id=file_id,
+            )
+            return False
+
     async def close(self) -> None:
         """Close service connections."""
         try:

src/services/orchestrator.py

@@ -155,6 +155,9 @@ async def execute(
             # This sets ctx.new_state_hash needed for file-state linking
             await self._save_state(ctx)
 
+            # Step 5.6: Update mounted files to capture in-place edits
+            await self._update_mounted_files_content(ctx)
+
             # Step 6: Handle generated files (with state_hash for linking)
             ctx.generated_files = await self._handle_generated_files(ctx)
 
@@ -555,6 +558,63 @@ async def _update_mounted_files_state_hash(
                     error=str(e),
                 )
 
+    async def _update_mounted_files_content(self, ctx: ExecutionContext) -> None:
+        """Re-upload all mounted files to capture any modifications.
+
+        This ensures in-place edits to mounted files persist after execution.
+        Called after execution completes, reads current content from container
+        and updates the file in MinIO storage.
+        """
+        if not ctx.mounted_files or not ctx.container:
+            return
+
+        container_manager = self.execution_service.container_manager
+
+        for file_info in ctx.mounted_files:
+            try:
+                filename = file_info.get("filename")
+                file_id = file_info.get("file_id")
+                session_id = file_info.get("session_id")
+
+                if not all([filename, file_id, session_id]):
+                    continue
+
+                # Read current content from container
+                file_path = f"/mnt/data/{filename}"
+                content = await container_manager.get_file_content_from_container(
+                    ctx.container, file_path
+                )
+
+                if content is None:
+                    # File may have been deleted - that's ok
+                    logger.debug(
+                        "Mounted file not found after execution",
+                        filename=filename,
+                    )
+                    continue
+
+                # Update file in storage
+                await self.file_service.update_file_content(
+                    session_id=session_id,
+                    file_id=file_id,
+                    content=content,
+                    state_hash=ctx.new_state_hash,
+                    execution_id=ctx.request_id,
+                )
+
+                logger.debug(
+                    "Updated mounted file content",
+                    filename=filename,
+                    size=len(content),
+                )
+
+            except Exception as e:
+                logger.warning(
+                    "Failed to update mounted file",
+                    filename=file_info.get("filename"),
+                    error=str(e),
+                )
+
     def _normalize_args(self, args: Any) -> Optional[List[str]]:
         """Normalize args parameter to List[str] or None.
 
@@ -591,7 +651,8 @@ async def _execute_code(self, ctx: ExecutionContext) -> Any:
         # Determine if we should use state persistence (Python only)
         use_state = settings.state_persistence_enabled and ctx.request.lang == "py"
 
-        # execute_code returns (execution, container, new_state, state_errors, container_source) tuple
+        # execute_code returns tuple:
+        # (execution, container, new_state, state_errors, container_source)
         (
             execution,
             ctx.container,