Skip to content

Commit ec8e836

Browse files
ayaangazaliclaudejbeckwith-oai
authored
fix(sandbox): scope exclusive Add File creation to UnixLocal (#4893)
* fix(sandbox): reject apply_patch create_file on an existing file Add File is documented to the model as creating a new file, and the delete and update operations both enforce their existing-file precondition. create_file enforced nothing, so an Add File operation aimed at a path that already existed overwrote it and reported "Created <path>", losing the previous contents with no error. Check that the destination is absent before writing, mirroring the existing _ensure_exists precondition used by delete_file. * fix(sandbox): keep the create precondition probe out of failed read spans The absence check reached SandboxSession.read(), which records a failed sandbox.read child span when the file is missing. Missing is the success case for a create, so every successful Add File looked like it contained a failed sandbox operation. Use the existing _read_with_expected_span_errors helper, the same path the skills capability already uses for an existence probe. * test(sandbox): skip the create span test on Windows The span assertion needs FilesystemTestSandboxSession, which is typed to UnixLocalSandboxSessionState, and importing agents.sandbox.sandboxes.unix_local raises ImportError on Windows by design. tests/conftest.py already collect-ignores the other files that depend on it, but test_apply_patch.py must stay collectible because its remaining tests are platform independent. The unix-only imports stay inside the test body so collection does not touch unix_local on Windows. * fix(sandbox): claim the create_file name at the backend write boundary The previous read-then-write check left a window: a concurrent sandbox command could create the file after the probe, and the unconditional write then destroyed that content. Reading also did not establish that a dangling symlink entry was absent, because the unix_local path policy resolves symlinks and the write landed on the link target. Add BaseSandboxSession.write_new_file(), which claims the target name before the payload is written and raises FileExistsError when the name is already taken. The shared implementation uses a shell noclobber redirection, so the redirect itself is the O_EXCL attempt; UnixLocal overrides it with os.open(O_CREAT|O_EXCL) for its direct path. Both validate the parent through the normal policy, preserving grants and the bound user, and leave the final component unresolved so a symlink at that name is rejected rather than followed. apply_patch create_file now uses it and drops the probe, so the tracing workaround for the probe read is no longer needed. Existing files still have to go through update_file. * fix(sandbox): link a completed payload into place for create_file Three problems with the previous commit. SandboxSession did not forward write_new_file, so a session built by SandboxClient fell back to the shared implementation and never reached the UnixLocal os.open override. Forward it. The shared implementation created an empty file and then wrote the payload in a separate step, so a concurrent writer could be overwritten and a failed upload left an empty file holding the name. Write the payload under a staging name first, then claim the target with ln, which fails when the name is taken. The content is complete before the name exists, and a failed create leaves only the staging entry, which is removed. The script used ':' for the noclobber redirection. ':' is a POSIX special builtin, so on dash a redirection failure ended the shell before the exit mapping ran and a collision surfaced as a generic write error instead of FileExistsError. ln is a regular command, and a test now runs the script through sh, dash and bash so this cannot regress silently. Also create local files with 0o666 so the process umask decides the final mode, matching Path.open("wb") on the ordinary write path. * fix(sandbox): claim the requested name, not its resolved target WorkspaceEditor normalizes the destination before dispatching, and UnixLocal resolves leaf symlinks, so create_file handed the primitive the link target. Add File on a dangling link.txt created missing.txt and reported success. Pass the unresolved path for create. Stage the payload locally too, then os.link it into place. os.link fails with EEXIST for a file, a directory or a dangling symlink, and a write that fails partway now leaves only the staging entry instead of a file holding the name. Reject a name held by a directory in the shared script. Bare ln treats an existing directory as a target directory and would have linked the staging file inside it while reporting the directory as created. Move the staging write inside the cleanup scope so a failed upload cannot leak the staging entry, and create the parent as the bound user so a fresh nested path is owned the way the previous write path owned it. The new tests drive session.apply_patch() rather than the primitive, which is the path that was actually broken. * fix(sandbox): drop the login shell and narrow the create collision Use sh -c instead of sh -lc for the exclusive create. This path runs for a filesystem-only capability set, so it must not source shell startup files that live in the workspace it is editing. A parent that is a regular file makes mkdir raise FileExistsError, and the broad handler reported that as a collision on the requested name, telling the model to use update_file for a target that does not exist. Only the os.link call can report a collision now; parent and staging failures are wrapped as write errors. * fix(sandbox): use a fixed-length staging basename The staging name was derived from the destination, so it was always longer than the destination itself. A filename that fits the filesystem's component limit, and that the ordinary write path accepts, could then fail to stage: a 254 character name raised WorkspaceArchiveWriteError where a plain write succeeded before this branch. The staging basename is now constant at 52 characters regardless of the destination. Reported by fscfede-beep in #4930. * fix(sandbox): classify a visible collision before staging the payload The staging write ran before the link script could classify the target, so a target inside an executable but non-writable parent failed on the staging write and the caller saw WorkspaceArchiveWriteError instead of the ApplyPatchDiffError that points it at update_file. It also meant an Add File onto an occupied name uploaded a payload that was then discarded. Probe the target first in both paths, then keep the atomic claim to decide real races. A creator that wins between the probe and the link still loses the name, and its staging entry is still cleaned up. Reported by Codex and by fscfede-beep in #4930. * fix(sandbox): build exclusive create on the descriptor-relative file ops #4931 gave UnixLocal a dir_fd plus O_NOFOLLOW file-ops layer and routed the bound-user path through a Python worker running that same module. That is the primitive this change was approximating, so use it instead. write_new is the existing write with O_TRUNC replaced by O_EXCL, which claims the name in the same syscall that creates the file and fails with EEXIST when the name is taken by a file, a directory, or a dangling symlink. The worker exits with a distinct status for an existing target so the caller can report FileExistsError rather than a generic write error. This deletes the machinery the previous approach needed: the shell script, the staging file, the hard link, and the staging cleanup. With no hard link there is nothing to fail on writable object-storage mounts or across owners under fs.protected_hardlinks, and with no staging entry there is nothing for concurrent work to replace. The shared base now documents what it actually guarantees: it rejects an occupied target but is not atomic, and a backend that can claim a name should override it. test_parent_swap_after_validation_cannot_access_outside[patch] injected at session.normalize_path, which the create path no longer calls, so its swap stopped firing. Re-pointed the patch case at the file-ops authorize boundary the create path does traverse, keeping the coverage rather than letting it pass vacuously. Verified separately that a parent symlinked outside the workspace is still refused, with the outside file untouched. Co-Authored-By: Claude Opus 5 <[email protected]> * fix(sandbox): keep supported parent symlinks and stop reading the target Two problems with the previous commit. Passing the whole path into the file ops unresolved made a supported internal symlink parent fail. The ordinary write path resolves those safe aliases, and test_safe_symlinks_grants_and_listing_paths_remain_supported establishes the support, but a create through "internal -> real" opened "internal" with O_NOFOLLOW | O_DIRECTORY and failed. Resolve the parent the way write does and keep only the leaf name unresolved, so a dangling symlink at the target name is still rejected without its target being created. The shared default probed the target with read(), which eagerly fetches the whole payload on the remote backends that inherit it. An Add File aimed at an existing large file would download it before reporting the collision, and an existing file the bound user cannot read reported a read failure instead of the collision. List the parent instead, which needs no payload and no read permission on the target. Both regressions have a test that fails on the unfixed source, including one asserting the rejected create issues no read at all. Co-Authored-By: Claude Opus 5 <[email protected]> * fix(sandbox): probe the target directly instead of listing its parent Listing the parent to decide a collision failed when the parent did not exist. BaseSandboxSession.ls() raises ExecNonZeroError in that case, which the probe did not catch, so a nested create such as newdir/file.txt aborted before write() on every backend inheriting the default, while succeeding on UnixLocal. Those backends' write paths create missing parents. Use a bare existence test instead. It needs only execute permission on the parent, never reads the target, and reports absent when the parent is missing so the create still reaches write(). Only a positive result rejects; any other probe outcome falls through rather than blocking a valid create. The test is also more accurate than the listing: it sees a file inside an executable but unreadable parent, which listing could not, so an existing file there is no longer silently overwritten. Validated the exact shipped script under sh, bash and dash for an existing file, a dangling symlink, an absent name, a missing parent, and a file in a 0311 parent. Co-Authored-By: Claude Opus 5 <[email protected]> * fix(sandbox): fail closed on a failed probe and keep scripted creates working Two problems with the previous commit. The probe treated any unexpected status as "absent" so a valid create would not be blocked. That was wrong: exit 0 already means absent, including when the parent does not exist, so the permissive fallback only covered the case where the probe itself did not run. On provider sessions whose write() uses a separate upload API, the write then succeeds and overwrites an existing target precisely when the precondition could not be checked. Only 0 may proceed now; 13 stays the collision and every other status is a write error. scripted_sandbox_session() broke. The inherited default reaches for exec, and a script that configures only file steps hides exec, so a previously valid mkdir-and-write script failed with AttributeError. Give the scripted session an implementation that consumes the same mkdir and write pair, and restore the explicit parent creation in the default so the observable call sequence matches what the create path did before this branch. Both have a test that fails on the unfixed source. Co-Authored-By: Claude Opus 5 <[email protected]> * fix(sandbox): keep scripted create calls on their normalized paths The create path hands write_new_file an unresolved path on purpose, so a symlink at the target name is rejected rather than followed. The scripted session forwarded that path straight into its compatibility mkdir and write pair, so a script using the documented match callback saw "." and "notes.txt" where it previously saw the workspace paths, and failed with SandboxCallMatcherError. Normalize before emitting the pair. Verified against the previous commit: with a custom manifest root the calls were "sub" and "sub/notes.txt" and are now "/custom/root/sub" and "/custom/root/sub/notes.txt", matching what this surface recorded before this branch. The earlier test only asserted method names, which is why it could not catch this. It now asserts the recorded paths too and fails on the unfixed source. * fix(sandbox): narrow exclusive creates and clarify partial-write recovery --------- Co-authored-by: Claude Opus 5 <[email protected]> Co-authored-by: Justin Beckwith <[email protected]>
1 parent 6492137 commit ec8e836

12 files changed

Lines changed: 675 additions & 5 deletions

‎src/agents/sandbox/apply_patch.py‎

Lines changed: 23 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -127,7 +127,11 @@ async def apply_operation(
127127
path=operation.path,
128128
cause=exc,
129129
) from exc
130-
await self._write_text(destination, created_text)
130+
# Hand over the unresolved path. destination has already been through
131+
# normalize_path(), which resolves leaf symlinks on some backends, so passing
132+
# it would ask the backend to create the link target instead of the requested
133+
# name and a dangling link would be reported as a successful create.
134+
await self._write_new_text(relative_path, created_text, display_path=display_path)
131135
return ApplyPatchResult(output=f"Created {display_path}")
132136

133137
raise ApplyPatchDiffError(
@@ -186,6 +190,24 @@ async def _ensure_exists(self, destination: Path, *, display_path: str) -> None:
186190
else:
187191
handle.close()
188192

193+
async def _write_new_text(self, destination: Path, text: str, *, display_path: str) -> None:
194+
# Backends with a native no-clobber primitive can reject occupied names.
195+
try:
196+
await self._session._write_new_file(
197+
destination,
198+
io.BytesIO(text.encode("utf-8")),
199+
user=self._user,
200+
)
201+
except FileExistsError as exc:
202+
raise ApplyPatchDiffError(
203+
message=(
204+
f"apply_patch cannot create {display_path} because it already exists. "
205+
"Use an update_file operation to change an existing file."
206+
),
207+
path=display_path,
208+
cause=exc,
209+
) from exc
210+
189211
async def _read_text(self, destination: Path, *, op_path: str, decode_path: Path) -> str:
190212
try:
191213
handle = await self._session.read(destination, user=self._user)

‎src/agents/sandbox/errors.py‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -506,9 +506,10 @@ def __init__(
506506
context: Mapping[str, object] | None = None,
507507
cause: BaseException | None = None,
508508
retryable: bool | None = None,
509+
message: str | None = None,
509510
) -> None:
510511
super().__init__(
511-
message=f"failed to write archive for path: {path}",
512+
message=message if message is not None else f"failed to write archive for path: {path}",
512513
error_code=ErrorCode.WORKSPACE_ARCHIVE_WRITE_ERROR,
513514
op="write",
514515
context={"path": str(path), **_as_context(context)},

‎src/agents/sandbox/sandboxes/_unix_local_file_ops.py‎

Lines changed: 44 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -26,6 +26,14 @@
2626
)
2727

2828

29+
_EXISTING_TARGET_EXIT_CODE = 13
30+
_INCOMPLETE_CREATE_EXIT_CODE = 14
31+
32+
33+
class _IncompleteCreateError(OSError):
34+
"""The destination was claimed, but writing its contents did not complete."""
35+
36+
2937
class _FileOps:
3038
"""Operate on canonical absolute paths already authorized by the owning session."""
3139

@@ -118,6 +126,34 @@ def write(self, path: Path, stream: io.IOBase) -> None:
118126
with out:
119127
shutil.copyfileobj(stream, out)
120128

129+
def write_new(self, path: Path, stream: io.IOBase) -> None:
130+
"""Create a file that must not already exist.
131+
132+
O_EXCL fails with EEXIST when the name is taken by anything, including a directory
133+
or a dangling symlink, and it claims the name in the same syscall that creates the
134+
file, so a concurrent creator either loses the race or keeps its own content.
135+
"""
136+
with self.parent(path, for_write=True, create_parents=True) as (parent_fd, name):
137+
fd = os.open(
138+
name,
139+
os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_NOFOLLOW,
140+
0o666,
141+
dir_fd=parent_fd,
142+
)
143+
try:
144+
try:
145+
out = os.fdopen(fd, "wb")
146+
except BaseException:
147+
os.close(fd)
148+
raise
149+
with out:
150+
shutil.copyfileobj(stream, out)
151+
except OSError as exc:
152+
# Do not unlink the name: another workspace operation may have replaced it.
153+
# Keep filesystem compatibility (no hard-link staging requirement) and let
154+
# the caller inspect and recover the partial result explicitly.
155+
raise _IncompleteCreateError("File creation did not complete") from exc
156+
121157
def mkdir(self, path: Path, *, parents: bool) -> None:
122158
with self.parent(path, for_write=True, create_parents=parents) as (parent_fd, name):
123159
try:
@@ -209,6 +245,14 @@ def _main() -> None:
209245
path = Path(raw_path)
210246
if operation == "write":
211247
files.write(path, cast(io.IOBase, sys.stdin.buffer))
248+
elif operation == "write_new":
249+
try:
250+
files.write_new(path, cast(io.IOBase, sys.stdin.buffer))
251+
except FileExistsError:
252+
# A distinct status keeps "already exists" separable from a real write failure.
253+
sys.exit(_EXISTING_TARGET_EXIT_CODE)
254+
except _IncompleteCreateError:
255+
sys.exit(_INCOMPLETE_CREATE_EXIT_CODE)
212256
elif operation == "ls":
213257
print(json.dumps(files.listing(path), ensure_ascii=True))
214258
else:

‎src/agents/sandbox/sandboxes/unix_local.py‎

Lines changed: 75 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -110,6 +110,12 @@
110110

111111
logger = logging.getLogger(__name__)
112112

113+
_INCOMPLETE_CREATE_MESSAGE = (
114+
"File creation failed after claiming the destination. The file may contain incomplete "
115+
"contents. Inspect the destination before using update_file or removing it to retry; "
116+
"retrying Add File without inspection is unsafe."
117+
)
118+
113119

114120
def _mount_path_diagnostic_extra(mount_path: Path) -> dict[str, object]:
115121
return {"mount_path": str(mount_path)}
@@ -1065,6 +1071,73 @@ async def write(
10651071
except OSError as e:
10661072
raise WorkspaceArchiveWriteError(path=workspace_path, cause=e) from e
10671073

1074+
async def _write_new_file(
1075+
self,
1076+
path: Path,
1077+
data: io.IOBase,
1078+
*,
1079+
user: str | User | None = None,
1080+
) -> None:
1081+
payload = coerce_write_payload(path=path, data=data)
1082+
# Resolve the parent the way the ordinary write path does, so a supported internal
1083+
# symlink such as "internal -> real" still works, then keep the leaf name
1084+
# unresolved so the file ops open it with O_NOFOLLOW and a symlink at the target
1085+
# name is rejected rather than followed.
1086+
requested = Path(path)
1087+
target = self.normalize_path(requested.parent, for_write=True) / requested.name
1088+
if user is not None:
1089+
await self._write_new_stream_with_exec(target, payload.stream, user=user)
1090+
return
1091+
1092+
try:
1093+
self._files.write_new(target, payload.stream)
1094+
except _unix_local_file_ops._IncompleteCreateError as e:
1095+
raise WorkspaceArchiveWriteError(
1096+
path=target,
1097+
cause=e,
1098+
retryable=False,
1099+
message=_INCOMPLETE_CREATE_MESSAGE,
1100+
) from e
1101+
except FileExistsError:
1102+
raise
1103+
except OSError as e:
1104+
raise WorkspaceArchiveWriteError(path=target, cause=e) from e
1105+
1106+
async def _write_new_stream_with_exec(
1107+
self,
1108+
path: Path,
1109+
stream: io.IOBase,
1110+
*,
1111+
user: str | User,
1112+
) -> None:
1113+
payload = stream.read()
1114+
if isinstance(payload, str):
1115+
payload = payload.encode("utf-8")
1116+
elif not isinstance(payload, bytes):
1117+
payload = bytes(payload)
1118+
try:
1119+
result = await self._run_file_operation_as_user(
1120+
"write_new", path, user=user, payload=payload
1121+
)
1122+
except OSError as e:
1123+
raise WorkspaceArchiveWriteError(path=path, cause=e) from e
1124+
if result.returncode == _unix_local_file_ops._EXISTING_TARGET_EXIT_CODE:
1125+
raise FileExistsError(str(path))
1126+
if result.returncode == _unix_local_file_ops._INCOMPLETE_CREATE_EXIT_CODE:
1127+
raise WorkspaceArchiveWriteError(
1128+
path=path,
1129+
retryable=False,
1130+
message=_INCOMPLETE_CREATE_MESSAGE,
1131+
)
1132+
if result.returncode:
1133+
raise WorkspaceArchiveWriteError(
1134+
path=path,
1135+
context={
1136+
"stderr": result.stderr.decode("utf-8", errors="replace"),
1137+
"operation": "write_new",
1138+
},
1139+
)
1140+
10681141
async def _write_stream_with_exec(
10691142
self,
10701143
path: Path,
@@ -1094,14 +1167,14 @@ async def _write_stream_with_exec(
10941167

10951168
async def _run_file_operation_as_user(
10961169
self,
1097-
operation: Literal["ls", "write"],
1170+
operation: Literal["ls", "write", "write_new"],
10981171
path: Path,
10991172
*,
11001173
user: str | User,
11011174
payload: bytes = b"",
11021175
) -> subprocess.CompletedProcess[bytes]:
11031176
# Authorization is synchronous and captured for this operation before dispatch.
1104-
path = self._files.authorize(path, for_write=operation == "write")
1177+
path = self._files.authorize(path, for_write=operation != "ls")
11051178
command = self._prepare_exec_command(
11061179
"python3",
11071180
"-I",

‎src/agents/sandbox/session/base_sandbox_session.py‎

Lines changed: 17 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -997,6 +997,23 @@ async def write(
997997
:param user: Optional sandbox user to perform the write as.
998998
"""
999999

1000+
async def _write_new_file(
1001+
self,
1002+
path: Path,
1003+
data: io.IOBase,
1004+
*,
1005+
user: str | User | None = None,
1006+
) -> None:
1007+
"""Backend hook for apply_patch creation.
1008+
1009+
The default retains the provider's existing mkdir/write semantics. UnixLocal
1010+
overrides this hook to claim the leaf exclusively; other backends need a native
1011+
primitive before they can offer the same guarantee.
1012+
"""
1013+
target = self.normalize_path(path)
1014+
await self.mkdir(target.parent, parents=True, user=user)
1015+
await self.write(target, data, user=user)
1016+
10001017
async def _check_read_with_exec(
10011018
self, path: Path | str, *, user: str | User | None = None
10021019
) -> Path:

‎src/agents/sandbox/session/sandbox_session.py‎

Lines changed: 13 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -684,6 +684,19 @@ async def write(
684684
) -> None:
685685
await self._inner.write(path, data, user=user)
686686

687+
@instrumented_op("write", data=_write_start_data)
688+
async def _write_new_file(
689+
self,
690+
path: Path,
691+
data: io.IOBase,
692+
*,
693+
user: str | User | None = None,
694+
) -> None:
695+
# Forwarded so a backend with a native exclusive-create primitive is actually
696+
# used. Without this the wrapper would fall back to the shared implementation and
697+
# bypass the inner session's override.
698+
await self._inner._write_new_file(path, data, user=user)
699+
687700
@instrumented_op(
688701
"running",
689702
finish_data=_running_finish_data,

‎tests/sandbox/_apply_patch_test_session.py‎

Lines changed: 14 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -56,6 +56,20 @@ async def write(
5656
else:
5757
self.files[normalized] = bytes(payload)
5858

59+
async def _write_new_file(
60+
self,
61+
path: Path,
62+
data: io.IOBase,
63+
*,
64+
user: str | User | None = None,
65+
) -> None:
66+
normalized = self.normalize_path(path)
67+
if normalized in self.files:
68+
raise FileExistsError(str(normalized))
69+
# Real backends create the parents inside the primitive, so record that here too.
70+
await self.mkdir(normalized.parent, parents=True, user=user)
71+
await self.write(path, data, user=user)
72+
5973
async def _exec_internal(
6074
self,
6175
*command: str | Path,

‎tests/sandbox/test_apply_patch.py‎

Lines changed: 50 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,6 @@
11
from __future__ import annotations
22

3+
import io
34
from pathlib import Path
45

56
import pytest
@@ -11,7 +12,9 @@
1112
ApplyPatchDiffError,
1213
ApplyPatchFileNotFoundError,
1314
ApplyPatchPathError,
15+
WorkspaceReadNotFoundError,
1416
)
17+
from agents.sandbox.types import User
1518
from tests.sandbox._apply_patch_test_session import (
1619
ApplyPatchSession,
1720
ProviderNotFoundApplyPatchSession,
@@ -411,3 +414,50 @@ async def test_apply_patch_mapping_operation_rejects_non_string_move_to() -> Non
411414
)
412415

413416
assert session.files[Path("/workspace/old.txt")] == b"alpha\n"
417+
418+
419+
@pytest.mark.asyncio
420+
async def test_apply_patch_create_rejects_an_existing_file() -> None:
421+
session = ApplyPatchSession()
422+
session.files[Path("/workspace/notes.txt")] = b"alpha\n"
423+
424+
with pytest.raises(ApplyPatchDiffError):
425+
await session.apply_patch(
426+
ApplyPatchOperation(
427+
type="create_file",
428+
path="notes.txt",
429+
diff="+beta\n",
430+
)
431+
)
432+
433+
assert session.files[Path("/workspace/notes.txt")] == b"alpha\n"
434+
435+
436+
class _AlwaysMissingReadApplyPatchSession(ApplyPatchSession):
437+
"""Reports every path as missing while still holding the file.
438+
439+
This stands in for a backend that provides an exclusive create. A create that only
440+
probed with read() would be told the path is free and would overwrite the stored
441+
content, so this pins the rejection to the backend primitive rather than to a probe.
442+
"""
443+
444+
async def read(self, path: Path, *, user: str | User | None = None) -> io.BytesIO:
445+
_ = (path, user)
446+
raise WorkspaceReadNotFoundError(path=path)
447+
448+
449+
@pytest.mark.asyncio
450+
async def test_apply_patch_create_rejects_an_existing_file_without_reading_it() -> None:
451+
session = _AlwaysMissingReadApplyPatchSession()
452+
session.files[Path("/workspace/notes.txt")] = b"alpha\n"
453+
454+
with pytest.raises(ApplyPatchDiffError):
455+
await session.apply_patch(
456+
ApplyPatchOperation(
457+
type="create_file",
458+
path="notes.txt",
459+
diff="+beta\n",
460+
)
461+
)
462+
463+
assert session.files[Path("/workspace/notes.txt")] == b"alpha\n"

0 commit comments

Comments
 (0)