axio-tools-docker 0.9.7__tar.gz → 0.9.9__tar.gz

{axio_tools_docker-0.9.7 → axio_tools_docker-0.9.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: axio-tools-docker
-Version: 0.9.7
+Version: 0.9.9
 Summary: Docker sandbox tools for Axio
 Project-URL: Documentation, https://docs.axio-agent.com
 Project-URL: Homepage, https://github.com/mosquito/axio-agent

{axio_tools_docker-0.9.7 → axio_tools_docker-0.9.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "axio-tools-docker"
-version = "0.9.7"
+version = "0.9.9"
 description = "Docker sandbox tools for Axio"
 readme = "README.md"
 requires-python = ">=3.12"

{axio_tools_docker-0.9.7 → axio_tools_docker-0.9.9}/src/axio_tools_docker/sandbox.py

@@ -72,18 +72,18 @@ async def shell(command: str, timeout: float = 5, cwd: str = ".", stdin: str | N
     return await sandbox.exec(cmd, timeout=timeout, stdin=stdin)
 
 
-async def write_file(file_path: str, content: str, mode: int = 0o644) -> str:
+async def write_file(path: str, content: str, mode: int = 0o644) -> str:
     """Create or overwrite a file with the given content. Parent directories
     are created automatically. Use this for new files or full rewrites.
     For partial edits prefer patch_file instead."""
     sandbox: DockerSandbox = CONTEXT.get()
-    path = _resolve_path(sandbox.workdir, file_path)
-    return await sandbox.write_file(path, content, mode=mode)
+    resolved = _resolve_path(sandbox.workdir, path)
+    return await sandbox.write_file(resolved, content, mode=mode)
 
 
 async def read_file(
-    filename: str,
-    max_chars: int = 32768,
+    path: str,
+    max_chars: int = 524288,  # ~128k tokens at ~4 chars/token
     binary_as_hex: bool = True,
     start_line: int | None = None,
     end_line: int | None = None,
@@ -96,8 +96,9 @@ async def read_file(
     are truncated to max_chars. Always read the file before editing it with
     write_file or patch_file."""
     sandbox: DockerSandbox = CONTEXT.get()
-    path = _resolve_path(sandbox.workdir, filename)
-    raw = await sandbox.read_file_bytes(path)
+    resolved = _resolve_path(sandbox.workdir, path)
+    sandbox._patched_files.discard(resolved)
+    raw = await sandbox.read_file_bytes(resolved)
     try:
         text = raw.decode()
     except UnicodeDecodeError:
@@ -117,14 +118,14 @@ async def read_file(
     return result
 
 
-async def list_files(directory: str = ".") -> str:
+async def list_files(path: str = ".") -> str:
     """List files and directories. Shows permissions, size, modification time,
     and name for each entry. Directories are listed first and marked with
     a trailing slash. Use this to explore the project structure before
     reading or editing files."""
     sandbox: DockerSandbox = CONTEXT.get()
-    path = _resolve_path(sandbox.workdir, directory)
-    tar = await sandbox.get_archive(path)
+    resolved = _resolve_path(sandbox.workdir, path)
+    tar = await sandbox.get_archive(resolved)
 
     members = tar.getmembers()
     if not members:
@@ -174,23 +175,37 @@ async def run_python(code: str, cwd: str = ".", timeout: float = 5, stdin: str |
     return await sandbox.exec(cmd, timeout=timeout, stdin=stdin)
 
 
-async def patch_file(file_path: str, from_line: int, to_line: int, content: str, mode: int = 0o644) -> str:
+async def patch_file(path: str, from_line: int, to_line: int, content: str, mode: int = 0o644) -> str:
     """Replace a range of lines in an existing file. Lines are 1-indexed:
     from_line and to_line are both inclusive (from_line=2, to_line=4 replaces
     lines 2, 3, 4). To insert without deleting, set to_line = from_line - 1.
     Always read the file first with line_numbers=True to get correct line numbers.
+    Patch each file at most once per read — re-read with line_numbers=True after
+    patching before issuing another patch to the same file.
     Use this for surgical edits instead of rewriting the whole file with
     write_file."""
     sandbox: DockerSandbox = CONTEXT.get()
-    path = _resolve_path(sandbox.workdir, file_path)
-    raw = await sandbox.read_file_bytes(path)
+    resolved = _resolve_path(sandbox.workdir, path)
+    if resolved in sandbox._patched_files:
+        raise RuntimeError(
+            f"{path!r} was already patched since the last read. "
+            "Re-read the file with line_numbers=True to get updated line numbers before patching again."
+        )
+    raw = await sandbox.read_file_bytes(resolved)
     lines = raw.decode().splitlines(keepends=True)
+    n = len(lines)
+    if not (1 <= from_line <= n + 1):
+        raise ValueError(f"from_line={from_line} out of range; file has {n} lines (valid: 1..{n + 1})")
+    if not (from_line - 1 <= to_line <= n):
+        raise ValueError(f"to_line={to_line} out of range (valid: {from_line - 1}..{n})")
     content_lines = content.splitlines(keepends=True)
     if content_lines and not content_lines[-1].endswith("\n"):
         content_lines[-1] += "\n"
     new_lines = lines[: from_line - 1] + content_lines + lines[to_line:]
-    await sandbox.write_file(path, "".join(new_lines), mode=mode)
-    return f"{len(new_lines)} lines written to {path}"
+    result = "".join(new_lines)
+    await sandbox.write_file(resolved, result, mode=mode)
+    sandbox._patched_files.add(resolved)
+    return f"{len(result)} bytes written to {resolved}"
 
 
 # ---------------------------------------------------------------------------
@@ -302,6 +317,7 @@ class DockerSandbox:
         self.privileged = privileged
         self.ulimits: dict[str, int | tuple[int, int]] = ulimits or {}
         self.tmpfs: dict[str, str] = tmpfs or {}
+        self._patched_files: set[str] = set()
         self.ports: dict[int, int] = ports or {}
         self.platform = platform
         self.extra_hosts: dict[str, str] = extra_hosts or {}
@@ -526,7 +542,12 @@ class DockerSandbox:
     async def get_archive(self, path: str) -> tarfile.TarFile:
         """Fetch a path from the container as a TarFile object."""
         assert self._container is not None
-        return cast(tarfile.TarFile, await self._container.get_archive(path=path))
+        try:
+            return cast(tarfile.TarFile, await self._container.get_archive(path=path))
+        except aiodocker.exceptions.DockerError as exc:
+            if exc.status == 404:
+                raise FileNotFoundError(f"No such file or directory: {path!r}") from exc
+            raise
 
     async def read_file_bytes(self, path: str) -> bytes:
         """Read a file from inside the container and return raw bytes."""

{axio_tools_docker-0.9.7 → axio_tools_docker-0.9.9}/tests/test_integration.py

@@ -94,14 +94,14 @@ async def test_write_file_mode(sandbox: DockerSandbox) -> None:
 async def test_read_file_line_range(sandbox: DockerSandbox) -> None:
     await sandbox.write_file("/workspace/lines.txt", "a\nb\nc\nd\ne\n")
     tool = next(t for t in sandbox.tools if t.name == "read_file")
-    result = await tool(filename="lines.txt", start_line=2, end_line=4)
+    result = await tool(path="lines.txt", start_line=2, end_line=4)
     assert result.strip() == "b\nc\nd"
 
 
 async def test_read_file_line_numbers(sandbox: DockerSandbox) -> None:
     await sandbox.write_file("/workspace/numbered.txt", "foo\nbar\n")
     tool = next(t for t in sandbox.tools if t.name == "read_file")
-    result = await tool(filename="numbered.txt", line_numbers=True)
+    result = await tool(path="numbered.txt", line_numbers=True)
     assert "1\tfoo" in result
     assert "2\tbar" in result
 
@@ -109,10 +109,17 @@ async def test_read_file_line_numbers(sandbox: DockerSandbox) -> None:
 async def test_read_file_truncation(sandbox: DockerSandbox) -> None:
     await sandbox.write_file("/workspace/big.txt", "x" * 100)
     tool = next(t for t in sandbox.tools if t.name == "read_file")
-    result = await tool(filename="big.txt", max_chars=10)
+    result = await tool(path="big.txt", max_chars=10)
     assert "truncated" in result
 
 
+async def test_read_file_missing_raises_file_not_found(sandbox: DockerSandbox) -> None:
+    # A 404 from the container archive endpoint must surface as a clear
+    # FileNotFoundError, not a raw Docker 404.
+    with pytest.raises(FileNotFoundError, match="No such file or directory"):
+        await sandbox.read_file_bytes("/workspace/nope.txt")
+
+
 async def test_list_files(sandbox: DockerSandbox) -> None:
     await sandbox.exec("mkdir -p /workspace/listing")
     await sandbox.write_file("/workspace/listing/a.py", "x")
@@ -120,7 +127,7 @@ async def test_list_files(sandbox: DockerSandbox) -> None:
     await sandbox.exec("mkdir -p /workspace/listing/subdir")
 
     tool = next(t for t in sandbox.tools if t.name == "list_files")
-    result = await tool(directory="/workspace/listing")
+    result = await tool(path="/workspace/listing")
 
     assert "a.py" in result
     assert "b.txt" in result
@@ -131,7 +138,7 @@ async def test_list_files(sandbox: DockerSandbox) -> None:
 async def test_patch_file(sandbox: DockerSandbox) -> None:
     await sandbox.write_file("/workspace/patch_me.txt", "line1\nline2\nline3\n")
     tool = next(t for t in sandbox.tools if t.name == "patch_file")
-    await tool(file_path="/workspace/patch_me.txt", from_line=2, to_line=2, content="REPLACED")
+    await tool(path="/workspace/patch_me.txt", from_line=2, to_line=2, content="REPLACED")
     raw = await sandbox.read_file_bytes("/workspace/patch_me.txt")
     assert raw == b"line1\nREPLACED\nline3\n"
 
@@ -140,11 +147,110 @@ async def test_patch_file_insert(sandbox: DockerSandbox) -> None:
     """to_line = from_line - 1 inserts without deleting."""
     await sandbox.write_file("/workspace/insert_me.txt", "line1\nline3\n")
     tool = next(t for t in sandbox.tools if t.name == "patch_file")
-    await tool(file_path="/workspace/insert_me.txt", from_line=2, to_line=1, content="line2")
+    await tool(path="/workspace/insert_me.txt", from_line=2, to_line=1, content="line2")
     raw = await sandbox.read_file_bytes("/workspace/insert_me.txt")
     assert raw == b"line1\nline2\nline3\n"
 
 
+# ---------------------------------------------------------------------------
+# patch_file validation
+# ---------------------------------------------------------------------------
+
+
+async def test_patch_file_from_line_zero_rejected(sandbox: DockerSandbox) -> None:
+    await sandbox.write_file("/workspace/v.txt", "a\nb\nc\n")
+    tool = next(t for t in sandbox.tools if t.name == "patch_file")
+    with pytest.raises(Exception, match="from_line=0"):
+        await tool(path="/workspace/v.txt", from_line=0, to_line=1, content="x")
+    assert await sandbox.read_file_bytes("/workspace/v.txt") == b"a\nb\nc\n"
+
+
+async def test_patch_file_negative_from_line_rejected(sandbox: DockerSandbox) -> None:
+    await sandbox.write_file("/workspace/v.txt", "a\nb\nc\n")
+    tool = next(t for t in sandbox.tools if t.name == "patch_file")
+    with pytest.raises(Exception, match="from_line=-1"):
+        await tool(path="/workspace/v.txt", from_line=-1, to_line=1, content="x")
+    assert await sandbox.read_file_bytes("/workspace/v.txt") == b"a\nb\nc\n"
+
+
+async def test_patch_file_from_line_beyond_end_rejected(sandbox: DockerSandbox) -> None:
+    await sandbox.write_file("/workspace/v.txt", "a\nb\nc\n")
+    tool = next(t for t in sandbox.tools if t.name == "patch_file")
+    with pytest.raises(Exception, match="from_line=5"):
+        await tool(path="/workspace/v.txt", from_line=5, to_line=5, content="x")
+    assert await sandbox.read_file_bytes("/workspace/v.txt") == b"a\nb\nc\n"
+
+
+async def test_patch_file_to_line_beyond_end_rejected(sandbox: DockerSandbox) -> None:
+    await sandbox.write_file("/workspace/v.txt", "a\nb\nc\n")
+    tool = next(t for t in sandbox.tools if t.name == "patch_file")
+    with pytest.raises(Exception, match="to_line=4"):
+        await tool(path="/workspace/v.txt", from_line=2, to_line=4, content="x")
+    assert await sandbox.read_file_bytes("/workspace/v.txt") == b"a\nb\nc\n"
+
+
+async def test_patch_file_gap_range_rejected(sandbox: DockerSandbox) -> None:
+    """from_line > to_line + 1 must be rejected."""
+    await sandbox.write_file("/workspace/v.txt", "a\nb\nc\nd\ne\n")
+    tool = next(t for t in sandbox.tools if t.name == "patch_file")
+    with pytest.raises(Exception, match="to_line=2"):
+        await tool(path="/workspace/v.txt", from_line=4, to_line=2, content="x")
+    assert await sandbox.read_file_bytes("/workspace/v.txt") == b"a\nb\nc\nd\ne\n"
+
+
+# ---------------------------------------------------------------------------
+# patch_file double-patching guard
+# ---------------------------------------------------------------------------
+
+
+async def test_patch_file_second_patch_rejected(sandbox: DockerSandbox) -> None:
+    """Second patch to the same file without re-reading must raise RuntimeError."""
+    await sandbox.write_file("/workspace/dp.txt", "a\nb\nc\n")
+    tool = next(t for t in sandbox.tools if t.name == "patch_file")
+    await tool(path="/workspace/dp.txt", from_line=1, to_line=1, content="A\n")
+    with pytest.raises(Exception, match="already patched"):
+        await tool(path="/workspace/dp.txt", from_line=2, to_line=2, content="B\n")
+    raw = await sandbox.read_file_bytes("/workspace/dp.txt")
+    assert raw == b"A\nb\nc\n"
+
+
+async def test_patch_file_read_clears_double_patch_guard(sandbox: DockerSandbox) -> None:
+    """Re-reading the file via the read_file tool clears the patch guard."""
+    await sandbox.write_file("/workspace/rg.txt", "a\nb\nc\n")
+    patch_tool = next(t for t in sandbox.tools if t.name == "patch_file")
+    read_tool = next(t for t in sandbox.tools if t.name == "read_file")
+    await patch_tool(path="/workspace/rg.txt", from_line=1, to_line=1, content="A\n")
+    await read_tool(path="/workspace/rg.txt", line_numbers=True)
+    await patch_tool(path="/workspace/rg.txt", from_line=2, to_line=2, content="B\n")
+    raw = await sandbox.read_file_bytes("/workspace/rg.txt")
+    assert raw == b"A\nB\nc\n"
+
+
+# ---------------------------------------------------------------------------
+# patch_file special file content
+# ---------------------------------------------------------------------------
+
+
+async def test_patch_file_null_bytes_in_preserved_lines_survive(sandbox: DockerSandbox) -> None:
+    """Null bytes in lines not being replaced must not be stripped."""
+    await sandbox.write_file("/workspace/null.txt", "line1\nline2\x00null\nline3\n")
+    tool = next(t for t in sandbox.tools if t.name == "patch_file")
+    await tool(path="/workspace/null.txt", from_line=1, to_line=1, content="replaced\n")
+    raw = await sandbox.read_file_bytes("/workspace/null.txt")
+    assert b"line2\x00null" in raw, "null byte in preserved line was stripped"
+    assert raw.startswith(b"replaced\n")
+
+
+async def test_patch_file_binary_file_raises_before_write(sandbox: DockerSandbox) -> None:
+    """Patching a non-UTF-8 binary file must fail before any modification."""
+    await sandbox.exec("python3 -c \"open('/workspace/bin.bin','wb').write(bytes(range(128,200)))\"")
+    tool = next(t for t in sandbox.tools if t.name == "patch_file")
+    original = await sandbox.read_file_bytes("/workspace/bin.bin")
+    with pytest.raises(Exception, match="codec can't decode"):
+        await tool(path="/workspace/bin.bin", from_line=1, to_line=1, content="hello\n")
+    assert await sandbox.read_file_bytes("/workspace/bin.bin") == original
+
+
 async def test_run_python(sandbox: DockerSandbox) -> None:
     tool = next(t for t in sandbox.tools if t.name == "run_python")
     result = await tool(code="print(2 + 2)")