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.pyindex eda371420..92dc42687 100644--- a/src/agent_tools/filesystem_tools.py+++ b/src/agent_tools/filesystem_tools.py@@ -3,6 +3,7 @@ import jsonimport osimport reimport difflib+import secretsimport shutilimport timefrom 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 toreplace 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"):+ passexcept 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.pyindex 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 withpath are still there afterwards; each "still works" test guards the write paththis change must not narrow."""+import builtinsimport jsonimport osimport re@@ -248,6 +249,36 @@ async def test_empty_body_does_not_truncate_a_file_created_after_the_absence_cheassert _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.asyncioasync def test_a_real_body_still_writes_and_reports_a_diff(target):_seed(target)