Skip to content

Self-hosted AI workspace.

Python

fix(tools): publish blank-body files atomically

Nicholai2992bf6d368a
diff --git a/src/agent_tools/filesystem_tools.py b/src/agent_tools/filesystem_tools.py
index eda371420..92dc42687 100644
--- a/src/agent_tools/filesystem_tools.py
+++ b/src/agent_tools/filesystem_tools.py
@@ -3,6 +3,7 @@ import json
import os
import re
import difflib
+import secrets
import shutil
import time
from typing import Optional, Dict, Any, Tuple, List
@@ -289,6 +290,37 @@ class ReadFileTool:
data = data[:MAX_READ_CHARS] + f"\n... [truncated at {MAX_READ_CHARS} chars]"
return {"output": data, "exit_code": 0}
+
+def _write_new_file_without_overwrite(path: str, body: str) -> None:
+ """Publish a new file without exposing a writable placeholder at its path.
+
+ Stage beside the destination, then hard-link it into place. The link is
+ atomic and fails if another writer created the destination first.
+ """
+ directory = os.path.dirname(path) or "."
+ temporary_path = os.path.join(
+ directory, f".odysseus-write-{secrets.token_hex(16)}.tmp"
+ )
+ fd = os.open(
+ temporary_path,
+ os.O_WRONLY | os.O_CREAT | os.O_EXCL,
+ 0o666,
+ )
+
+ try:
+ with os.fdopen(fd, "w", encoding="utf-8") as temporary_file:
+ fd = None
+ temporary_file.write(body)
+ os.link(temporary_path, path)
+ finally:
+ if fd is not None:
+ os.close(fd)
+ try:
+ os.unlink(temporary_path)
+ except FileNotFoundError:
+ pass
+
+
class _EmptyBodyWouldTruncate(Exception):
"""Raised inside the write thread when an undeclared empty body is about to
replace a file that holds bytes. Carries the size at risk so the caller can be
@@ -358,11 +390,17 @@ class WriteFileTool:
raise _EmptyBodyWouldTruncate(path, existing_bytes)
return old, 0
- # Create a missing target exclusively. If another writer wins
- # the race, inspect what appeared rather than truncating it.
try:
- with open(path, "x", encoding="utf-8") as f:
- f.write(body)
+ if body:
+ # Publish whitespace content atomically. Writing it
+ # after exclusive creation could overwrite bytes from
+ # a writer that filled the new placeholder meanwhile.
+ _write_new_file_without_overwrite(path, body)
+ else:
+ # An exact empty body needs no staged data, so create
+ # the file exclusively and never write through it.
+ with open(path, "x", encoding="utf-8"):
+ pass
except FileExistsError:
if os.path.isfile(path):
existing_bytes = os.path.getsize(path)
diff --git a/tests/test_write_file_empty_body.py b/tests/test_write_file_empty_body.py
index 55dc35163..9b735f15d 100644
--- a/tests/test_write_file_empty_body.py
+++ b/tests/test_write_file_empty_body.py
@@ -7,6 +7,7 @@ existing file is opened in "w" mode, and the tool answers exit_code=0 with
path are still there afterwards; each "still works" test guards the write path
this change must not narrow.
"""
+import builtins
import json
import os
import re
@@ -248,6 +249,36 @@ async def test_empty_body_does_not_truncate_a_file_created_after_the_absence_che
assert _read(target) == "concurrent update"
+async def test_whitespace_body_does_not_clobber_a_concurrent_creation(
+ target, monkeypatch
+):
+ """Whitespace on a missing path must not overwrite a competing writer."""
+ real_open = builtins.open
+ real_link = os.link
+
+ def write_concurrent_content(path):
+ with real_open(path, "w", encoding="utf-8") as concurrent:
+ concurrent.write("concurrent update")
+
+ def interleaved_open(path, mode="r", *args, **kwargs):
+ handle = real_open(path, mode, *args, **kwargs)
+ if path == target and mode == "x":
+ write_concurrent_content(path)
+ return handle
+
+ def interleaved_link(source, destination, *args, **kwargs):
+ if destination == target:
+ write_concurrent_content(destination)
+ return real_link(source, destination, *args, **kwargs)
+
+ monkeypatch.setattr(builtins, "open", interleaved_open)
+ monkeypatch.setattr(os, "link", interleaved_link)
+ res = await WriteFileTool().execute(_text_call(target, " \n\t"), {})
+ assert res["exit_code"] == 1, res
+ assert _read(target) == "concurrent update"
+
+
@pytest.mark.asyncio
async def test_a_real_body_still_writes_and_reports_a_diff(target):
_seed(target)