@vellumai/assistant 0.4.17 → 0.4.18

package/src/__tests__/filesystem-tools.test.ts

@@ -7,15 +7,20 @@ import {
   rmSync,
   symlinkSync,
   writeFileSync,
-} from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, test } from "bun:test";
 
-import { afterEach, describe, expect, test } from 'bun:test';
-
-import { FileSystemOps, type PathPolicy } from '../tools/shared/filesystem/file-ops-service.js';
-import { formatEditDiff, formatWriteSummary } from '../tools/shared/filesystem/format-diff.js';
-import { sandboxPolicy } from '../tools/shared/filesystem/path-policy.js';
+import {
+  FileSystemOps,
+  type PathPolicy,
+} from "../tools/shared/filesystem/file-ops-service.js";
+import {
+  formatEditDiff,
+  formatWriteSummary,
+} from "../tools/shared/filesystem/format-diff.js";
+import { sandboxPolicy } from "../tools/shared/filesystem/path-policy.js";
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -24,7 +29,7 @@ import { sandboxPolicy } from '../tools/shared/filesystem/path-policy.js';
 const testDirs: string[] = [];
 
 function makeTempDir(): string {
-  const dir = realpathSync(mkdtempSync(join(tmpdir(), 'fs-tools-test-')));
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "fs-tools-test-")));
   testDirs.push(dir);
   return dir;
 }
@@ -43,68 +48,71 @@ function sandboxPolicyFor(boundary: string): PathPolicy {
 // FileSystemOps: symlink handling through read/write/edit
 // ===========================================================================
 
-describe('FileSystemOps symlink handling', () => {
-  test('read blocks symlink pointing outside boundary', () => {
+describe("FileSystemOps symlink handling", () => {
+  test("read blocks symlink pointing outside boundary", () => {
     const boundary = makeTempDir();
     const outside = makeTempDir();
-    const outsideFile = join(outside, 'secret.txt');
-    writeFileSync(outsideFile, 'secret data');
+    const outsideFile = join(outside, "secret.txt");
+    writeFileSync(outsideFile, "secret data");
 
-    symlinkSync(outsideFile, join(boundary, 'link.txt'));
+    symlinkSync(outsideFile, join(boundary, "link.txt"));
     const ops = new FileSystemOps(sandboxPolicyFor(boundary));
 
-    const result = ops.readFileSafe({ path: 'link.txt' });
+    const result = ops.readFileSafe({ path: "link.txt" });
     expect(result.ok).toBe(false);
     if (result.ok) return;
-    expect(result.error.code).toBe('PATH_OUT_OF_BOUNDS');
+    expect(result.error.code).toBe("PATH_OUT_OF_BOUNDS");
   });
 
-  test('read allows symlink within boundary', () => {
+  test("read allows symlink within boundary", () => {
     const boundary = makeTempDir();
-    const realFile = join(boundary, 'real.txt');
-    writeFileSync(realFile, 'hello');
-    symlinkSync(realFile, join(boundary, 'link.txt'));
+    const realFile = join(boundary, "real.txt");
+    writeFileSync(realFile, "hello");
+    symlinkSync(realFile, join(boundary, "link.txt"));
 
     const ops = new FileSystemOps(sandboxPolicyFor(boundary));
-    const result = ops.readFileSafe({ path: 'link.txt' });
+    const result = ops.readFileSafe({ path: "link.txt" });
     expect(result.ok).toBe(true);
     if (!result.ok) return;
-    expect(result.value.content).toContain('hello');
+    expect(result.value.content).toContain("hello");
   });
 
-  test('write blocks creating file under symlinked dir pointing outside', () => {
+  test("write blocks creating file under symlinked dir pointing outside", () => {
     const boundary = makeTempDir();
     const outside = makeTempDir();
-    symlinkSync(outside, join(boundary, 'link-dir'));
+    symlinkSync(outside, join(boundary, "link-dir"));
 
     const ops = new FileSystemOps(sandboxPolicyFor(boundary));
-    const result = ops.writeFileSafe({ path: 'link-dir/evil.txt', content: 'bad' });
+    const result = ops.writeFileSafe({
+      path: "link-dir/evil.txt",
+      content: "bad",
+    });
     expect(result.ok).toBe(false);
     if (result.ok) return;
-    expect(result.error.code).toBe('PATH_OUT_OF_BOUNDS');
+    expect(result.error.code).toBe("PATH_OUT_OF_BOUNDS");
     // The file must NOT have been written to the outside directory
-    expect(existsSync(join(outside, 'evil.txt'))).toBe(false);
+    expect(existsSync(join(outside, "evil.txt"))).toBe(false);
   });
 
-  test('edit blocks symlink pointing outside boundary', () => {
+  test("edit blocks symlink pointing outside boundary", () => {
     const boundary = makeTempDir();
     const outside = makeTempDir();
-    const outsideFile = join(outside, 'target.txt');
-    writeFileSync(outsideFile, 'original');
-    symlinkSync(outsideFile, join(boundary, 'link.txt'));
+    const outsideFile = join(outside, "target.txt");
+    writeFileSync(outsideFile, "original");
+    symlinkSync(outsideFile, join(boundary, "link.txt"));
 
     const ops = new FileSystemOps(sandboxPolicyFor(boundary));
     const result = ops.editFileSafe({
-      path: 'link.txt',
-      oldString: 'original',
-      newString: 'modified',
+      path: "link.txt",
+      oldString: "original",
+      newString: "modified",
       replaceAll: false,
     });
     expect(result.ok).toBe(false);
     if (result.ok) return;
-    expect(result.error.code).toBe('PATH_OUT_OF_BOUNDS');
+    expect(result.error.code).toBe("PATH_OUT_OF_BOUNDS");
     // The outside file must NOT have been modified
-    expect(readFileSync(outsideFile, 'utf-8')).toBe('original');
+    expect(readFileSync(outsideFile, "utf-8")).toBe("original");
   });
 });
 
@@ -112,66 +120,70 @@ describe('FileSystemOps symlink handling', () => {
 // FileSystemOps: read offset/limit edge cases
 // ===========================================================================
 
-describe('FileSystemOps read offset/limit edge cases', () => {
-  test('offset beyond file length returns empty content', () => {
+describe("FileSystemOps read offset/limit edge cases", () => {
+  test("offset beyond file length returns empty content", () => {
     const dir = makeTempDir();
-    writeFileSync(join(dir, 'short.txt'), 'a\nb\nc');
+    writeFileSync(join(dir, "short.txt"), "a\nb\nc");
     const ops = new FileSystemOps(sandboxPolicyFor(dir));
 
-    const result = ops.readFileSafe({ path: 'short.txt', offset: 100 });
+    const result = ops.readFileSafe({ path: "short.txt", offset: 100 });
     expect(result.ok).toBe(true);
     if (!result.ok) return;
-    expect(result.value.content).toBe('');
+    expect(result.value.content).toBe("");
   });
 
-  test('limit of zero returns empty content', () => {
+  test("limit of zero returns empty content", () => {
     const dir = makeTempDir();
-    writeFileSync(join(dir, 'file.txt'), 'a\nb\nc');
+    writeFileSync(join(dir, "file.txt"), "a\nb\nc");
     const ops = new FileSystemOps(sandboxPolicyFor(dir));
 
-    const result = ops.readFileSafe({ path: 'file.txt', limit: 0 });
+    const result = ops.readFileSafe({ path: "file.txt", limit: 0 });
     expect(result.ok).toBe(true);
     if (!result.ok) return;
-    expect(result.value.content).toBe('');
+    expect(result.value.content).toBe("");
   });
 
-  test('offset=1 reads from first line (1-indexed)', () => {
+  test("offset=1 reads from first line (1-indexed)", () => {
     const dir = makeTempDir();
-    writeFileSync(join(dir, 'file.txt'), 'first\nsecond\nthird');
+    writeFileSync(join(dir, "file.txt"), "first\nsecond\nthird");
     const ops = new FileSystemOps(sandboxPolicyFor(dir));
 
-    const result = ops.readFileSafe({ path: 'file.txt', offset: 1, limit: 1 });
+    const result = ops.readFileSafe({ path: "file.txt", offset: 1, limit: 1 });
     expect(result.ok).toBe(true);
     if (!result.ok) return;
-    expect(result.value.content).toContain('first');
-    expect(result.value.content).not.toContain('second');
+    expect(result.value.content).toContain("first");
+    expect(result.value.content).not.toContain("second");
   });
 
-  test('limit exceeding file length returns all remaining lines', () => {
+  test("limit exceeding file length returns all remaining lines", () => {
     const dir = makeTempDir();
-    writeFileSync(join(dir, 'file.txt'), 'a\nb');
+    writeFileSync(join(dir, "file.txt"), "a\nb");
     const ops = new FileSystemOps(sandboxPolicyFor(dir));
 
-    const result = ops.readFileSafe({ path: 'file.txt', offset: 1, limit: 1000 });
+    const result = ops.readFileSafe({
+      path: "file.txt",
+      offset: 1,
+      limit: 1000,
+    });
     expect(result.ok).toBe(true);
     if (!result.ok) return;
-    expect(result.value.content).toContain('a');
-    expect(result.value.content).toContain('b');
+    expect(result.value.content).toContain("a");
+    expect(result.value.content).toContain("b");
   });
 
-  test('read adds line numbers starting from offset', () => {
+  test("read adds line numbers starting from offset", () => {
     const dir = makeTempDir();
-    writeFileSync(join(dir, 'file.txt'), 'a\nb\nc\nd\ne');
+    writeFileSync(join(dir, "file.txt"), "a\nb\nc\nd\ne");
     const ops = new FileSystemOps(sandboxPolicyFor(dir));
 
-    const result = ops.readFileSafe({ path: 'file.txt', offset: 3, limit: 2 });
+    const result = ops.readFileSafe({ path: "file.txt", offset: 3, limit: 2 });
     expect(result.ok).toBe(true);
     if (!result.ok) return;
     // Lines should be numbered 3 and 4
-    expect(result.value.content).toContain('3');
-    expect(result.value.content).toContain('4');
-    expect(result.value.content).toContain('c');
-    expect(result.value.content).toContain('d');
+    expect(result.value.content).toContain("3");
+    expect(result.value.content).toContain("4");
+    expect(result.value.content).toContain("c");
+    expect(result.value.content).toContain("d");
   });
 });
 
@@ -179,58 +191,61 @@ describe('FileSystemOps read offset/limit edge cases', () => {
 // FileSystemOps: edit with whitespace-normalized and fuzzy matches
 // ===========================================================================
 
-describe('FileSystemOps edit match methods', () => {
-  test('whitespace-normalized match succeeds', () => {
+describe("FileSystemOps edit match methods", () => {
+  test("whitespace-normalized match succeeds", () => {
     const dir = makeTempDir();
-    writeFileSync(join(dir, 'file.txt'), '  function foo() {\n    return 1;\n  }\n');
+    writeFileSync(
+      join(dir, "file.txt"),
+      "  function foo() {\n    return 1;\n  }\n",
+    );
     const ops = new FileSystemOps(sandboxPolicyFor(dir));
 
     const result = ops.editFileSafe({
-      path: 'file.txt',
-      oldString: 'function foo() {\n  return 1;\n}',
-      newString: 'function bar() {\n  return 2;\n}',
+      path: "file.txt",
+      oldString: "function foo() {\n  return 1;\n}",
+      newString: "function bar() {\n  return 2;\n}",
       replaceAll: false,
     });
     expect(result.ok).toBe(true);
     if (!result.ok) return;
-    expect(result.value.matchMethod).toBe('whitespace');
+    expect(result.value.matchMethod).toBe("whitespace");
     expect(result.value.similarity).toBe(1);
-    expect(result.value.newContent).toContain('bar');
+    expect(result.value.newContent).toContain("bar");
   });
 
-  test('fuzzy match succeeds with near-match', () => {
+  test("fuzzy match succeeds with near-match", () => {
     const dir = makeTempDir();
-    writeFileSync(join(dir, 'file.txt'), 'function fooo() {\n  return 1;\n}\n');
+    writeFileSync(join(dir, "file.txt"), "function fooo() {\n  return 1;\n}\n");
     const ops = new FileSystemOps(sandboxPolicyFor(dir));
 
     const result = ops.editFileSafe({
-      path: 'file.txt',
-      oldString: 'function foo() {\n  return 1;\n}',
-      newString: 'function bar() {\n  return 2;\n}',
+      path: "file.txt",
+      oldString: "function foo() {\n  return 1;\n}",
+      newString: "function bar() {\n  return 2;\n}",
       replaceAll: false,
     });
     expect(result.ok).toBe(true);
     if (!result.ok) return;
-    expect(result.value.matchMethod).toBe('fuzzy');
+    expect(result.value.matchMethod).toBe("fuzzy");
     expect(result.value.similarity).toBeGreaterThan(0.8);
     expect(result.value.similarity).toBeLessThan(1);
   });
 
-  test('edit returns actualOld and actualNew for fuzzy match', () => {
+  test("edit returns actualOld and actualNew for fuzzy match", () => {
     const dir = makeTempDir();
-    writeFileSync(join(dir, 'file.txt'), 'function fooo() {\n  return 1;\n}\n');
+    writeFileSync(join(dir, "file.txt"), "function fooo() {\n  return 1;\n}\n");
     const ops = new FileSystemOps(sandboxPolicyFor(dir));
 
     const result = ops.editFileSafe({
-      path: 'file.txt',
-      oldString: 'function foo() {\n  return 1;\n}',
-      newString: 'function bar() {\n  return 2;\n}',
+      path: "file.txt",
+      oldString: "function foo() {\n  return 1;\n}",
+      newString: "function bar() {\n  return 2;\n}",
       replaceAll: false,
     });
     expect(result.ok).toBe(true);
     if (!result.ok) return;
     // actualOld should be the text as it appeared in the file
-    expect(result.value.actualOld).toContain('fooo');
+    expect(result.value.actualOld).toContain("fooo");
   });
 });
 
@@ -238,39 +253,42 @@ describe('FileSystemOps edit match methods', () => {
 // FileSystemOps: write overwrites and oldContent tracking
 // ===========================================================================
 
-describe('FileSystemOps write content tracking', () => {
-  test('new file has empty oldContent', () => {
+describe("FileSystemOps write content tracking", () => {
+  test("new file has empty oldContent", () => {
     const dir = makeTempDir();
     const ops = new FileSystemOps(sandboxPolicyFor(dir));
 
-    const result = ops.writeFileSafe({ path: 'brand-new.txt', content: 'new' });
+    const result = ops.writeFileSafe({ path: "brand-new.txt", content: "new" });
     expect(result.ok).toBe(true);
     if (!result.ok) return;
-    expect(result.value.oldContent).toBe('');
+    expect(result.value.oldContent).toBe("");
     expect(result.value.isNewFile).toBe(true);
   });
 
-  test('overwrite tracks oldContent and newContent', () => {
+  test("overwrite tracks oldContent and newContent", () => {
     const dir = makeTempDir();
-    writeFileSync(join(dir, 'existing.txt'), 'version 1');
+    writeFileSync(join(dir, "existing.txt"), "version 1");
     const ops = new FileSystemOps(sandboxPolicyFor(dir));
 
-    const result = ops.writeFileSafe({ path: 'existing.txt', content: 'version 2' });
+    const result = ops.writeFileSafe({
+      path: "existing.txt",
+      content: "version 2",
+    });
     expect(result.ok).toBe(true);
     if (!result.ok) return;
-    expect(result.value.oldContent).toBe('version 1');
-    expect(result.value.newContent).toBe('version 2');
+    expect(result.value.oldContent).toBe("version 1");
+    expect(result.value.newContent).toBe("version 2");
     expect(result.value.isNewFile).toBe(false);
   });
 
-  test('write returns resolved absolute path', () => {
+  test("write returns resolved absolute path", () => {
     const dir = makeTempDir();
     const ops = new FileSystemOps(sandboxPolicyFor(dir));
 
-    const result = ops.writeFileSafe({ path: 'output.txt', content: 'data' });
+    const result = ops.writeFileSafe({ path: "output.txt", content: "data" });
     expect(result.ok).toBe(true);
     if (!result.ok) return;
-    expect(result.value.filePath).toBe(join(dir, 'output.txt'));
+    expect(result.value.filePath).toBe(join(dir, "output.txt"));
   });
 });
 
@@ -278,39 +296,41 @@ describe('FileSystemOps write content tracking', () => {
 // formatEditDiff
 // ===========================================================================
 
-describe('formatEditDiff', () => {
-  test('shows removed and added lines', () => {
-    const result = formatEditDiff('old line', 'new line');
-    expect(result).toContain('- old line');
-    expect(result).toContain('+ new line');
+describe("formatEditDiff", () => {
+  test("shows removed and added lines", () => {
+    const result = formatEditDiff("old line", "new line");
+    expect(result).toContain("- old line");
+    expect(result).toContain("+ new line");
   });
 
-  test('handles multi-line changes', () => {
-    const result = formatEditDiff('a\nb\nc', 'x\ny\nz');
-    expect(result).toContain('- a');
-    expect(result).toContain('- b');
-    expect(result).toContain('- c');
-    expect(result).toContain('+ x');
-    expect(result).toContain('+ y');
-    expect(result).toContain('+ z');
+  test("handles multi-line changes", () => {
+    const result = formatEditDiff("a\nb\nc", "x\ny\nz");
+    expect(result).toContain("- a");
+    expect(result).toContain("- b");
+    expect(result).toContain("- c");
+    expect(result).toContain("+ x");
+    expect(result).toContain("+ y");
+    expect(result).toContain("+ z");
   });
 
-  test('handles empty old string (pure addition)', () => {
-    const result = formatEditDiff('', 'added');
-    expect(result).not.toContain('- ');
-    expect(result).toContain('+ added');
+  test("handles empty old string (pure addition)", () => {
+    const result = formatEditDiff("", "added");
+    expect(result).not.toContain("- ");
+    expect(result).toContain("+ added");
   });
 
-  test('handles empty new string (pure deletion)', () => {
-    const result = formatEditDiff('removed', '');
-    expect(result).toContain('- removed');
-    expect(result).not.toContain('+ ');
+  test("handles empty new string (pure deletion)", () => {
+    const result = formatEditDiff("removed", "");
+    expect(result).toContain("- removed");
+    expect(result).not.toContain("+ ");
   });
 
-  test('truncates long diffs beyond 8 lines', () => {
-    const longOld = Array.from({ length: 12 }, (_, i) => `old-line-${i}`).join('\n');
-    const result = formatEditDiff(longOld, 'short');
-    expect(result).toContain('more lines');
+  test("truncates long diffs beyond 8 lines", () => {
+    const longOld = Array.from({ length: 12 }, (_, i) => `old-line-${i}`).join(
+      "\n",
+    );
+    const result = formatEditDiff(longOld, "short");
+    expect(result).toContain("more lines");
   });
 });
 
@@ -318,23 +338,23 @@ describe('formatEditDiff', () => {
 // formatWriteSummary
 // ===========================================================================
 
-describe('formatWriteSummary', () => {
-  test('new file summary includes line count', () => {
-    const result = formatWriteSummary('', 'line1\nline2\nline3', true);
-    expect(result).toContain('new file');
-    expect(result).toContain('3 lines');
+describe("formatWriteSummary", () => {
+  test("new file summary includes line count", () => {
+    const result = formatWriteSummary("", "line1\nline2\nline3", true);
+    expect(result).toContain("new file");
+    expect(result).toContain("3 lines");
   });
 
-  test('new file with single line uses singular', () => {
-    const result = formatWriteSummary('', 'single', true);
-    expect(result).toContain('1 line');
-    expect(result).not.toContain('1 lines');
+  test("new file with single line uses singular", () => {
+    const result = formatWriteSummary("", "single", true);
+    expect(result).toContain("1 line");
+    expect(result).not.toContain("1 lines");
   });
 
-  test('overwrite summary shows line count change', () => {
-    const result = formatWriteSummary('a\nb', 'x\ny\nz', false);
-    expect(result).toContain('2');
-    expect(result).toContain('3');
+  test("overwrite summary shows line count change", () => {
+    const result = formatWriteSummary("a\nb", "x\ny\nz", false);
+    expect(result).toContain("2");
+    expect(result).toContain("3");
   });
 });
 
@@ -342,62 +362,65 @@ describe('formatWriteSummary', () => {
 // FileSystemOps: path traversal patterns
 // ===========================================================================
 
-describe('FileSystemOps path traversal prevention', () => {
-  test('rejects absolute path outside boundary on read', () => {
+describe("FileSystemOps path traversal prevention", () => {
+  test("rejects absolute path outside boundary on read", () => {
     const dir = makeTempDir();
     const ops = new FileSystemOps(sandboxPolicyFor(dir));
 
-    const result = ops.readFileSafe({ path: '/etc/passwd' });
+    const result = ops.readFileSafe({ path: "/etc/passwd" });
     expect(result.ok).toBe(false);
     if (result.ok) return;
-    expect(result.error.code).toBe('PATH_OUT_OF_BOUNDS');
+    expect(result.error.code).toBe("PATH_OUT_OF_BOUNDS");
   });
 
-  test('rejects absolute path outside boundary on write', () => {
+  test("rejects absolute path outside boundary on write", () => {
     const dir = makeTempDir();
     const ops = new FileSystemOps(sandboxPolicyFor(dir));
 
-    const result = ops.writeFileSafe({ path: '/tmp/evil-write.txt', content: 'bad' });
+    const result = ops.writeFileSafe({
+      path: "/tmp/evil-write.txt",
+      content: "bad",
+    });
     expect(result.ok).toBe(false);
     if (result.ok) return;
-    expect(result.error.code).toBe('PATH_OUT_OF_BOUNDS');
+    expect(result.error.code).toBe("PATH_OUT_OF_BOUNDS");
   });
 
-  test('rejects absolute path outside boundary on edit', () => {
+  test("rejects absolute path outside boundary on edit", () => {
     const dir = makeTempDir();
     const ops = new FileSystemOps(sandboxPolicyFor(dir));
 
     const result = ops.editFileSafe({
-      path: '/etc/hosts',
-      oldString: 'a',
-      newString: 'b',
+      path: "/etc/hosts",
+      oldString: "a",
+      newString: "b",
       replaceAll: false,
     });
     expect(result.ok).toBe(false);
     if (result.ok) return;
-    expect(result.error.code).toBe('PATH_OUT_OF_BOUNDS');
+    expect(result.error.code).toBe("PATH_OUT_OF_BOUNDS");
   });
 
-  test('rejects dot-dot traversal embedded in path on read', () => {
+  test("rejects dot-dot traversal embedded in path on read", () => {
     const dir = makeTempDir();
-    mkdirSync(join(dir, 'sub'));
+    mkdirSync(join(dir, "sub"));
     const ops = new FileSystemOps(sandboxPolicyFor(dir));
 
-    const result = ops.readFileSafe({ path: 'sub/../../etc/passwd' });
+    const result = ops.readFileSafe({ path: "sub/../../etc/passwd" });
     expect(result.ok).toBe(false);
     if (result.ok) return;
-    expect(result.error.code).toBe('PATH_OUT_OF_BOUNDS');
+    expect(result.error.code).toBe("PATH_OUT_OF_BOUNDS");
   });
 
-  test('accepts absolute path inside boundary', () => {
+  test("accepts absolute path inside boundary", () => {
     const dir = makeTempDir();
-    writeFileSync(join(dir, 'inside.txt'), 'safe content');
+    writeFileSync(join(dir, "inside.txt"), "safe content");
     const ops = new FileSystemOps(sandboxPolicyFor(dir));
 
-    const result = ops.readFileSafe({ path: join(dir, 'inside.txt') });
+    const result = ops.readFileSafe({ path: join(dir, "inside.txt") });
     expect(result.ok).toBe(true);
     if (!result.ok) return;
-    expect(result.value.content).toContain('safe content');
+    expect(result.value.content).toContain("safe content");
   });
 });
 
@@ -405,14 +428,14 @@ describe('FileSystemOps path traversal prevention', () => {
 // FileSystemOps: binary file handling on read
 // ===========================================================================
 
-describe('FileSystemOps binary file read', () => {
-  test('reads binary content as utf-8 without crashing', () => {
+describe("FileSystemOps binary file read", () => {
+  test("reads binary content as utf-8 without crashing", () => {
     const dir = makeTempDir();
-    const binaryContent = Buffer.from([0x00, 0xFF, 0x89, 0x50, 0x4E, 0x47]);
-    writeFileSync(join(dir, 'binary.bin'), binaryContent);
+    const binaryContent = Buffer.from([0x00, 0xff, 0x89, 0x50, 0x4e, 0x47]);
+    writeFileSync(join(dir, "binary.bin"), binaryContent);
     const ops = new FileSystemOps(sandboxPolicyFor(dir));
 
-    const result = ops.readFileSafe({ path: 'binary.bin' });
+    const result = ops.readFileSafe({ path: "binary.bin" });
     // Should succeed — the file is readable, even if content has replacement chars
     expect(result.ok).toBe(true);
   });
@@ -422,44 +445,44 @@ describe('FileSystemOps binary file read', () => {
 // FileSystemOps: empty file handling
 // ===========================================================================
 
-describe('FileSystemOps empty file operations', () => {
-  test('reads empty file successfully', () => {
+describe("FileSystemOps empty file operations", () => {
+  test("reads empty file successfully", () => {
     const dir = makeTempDir();
-    writeFileSync(join(dir, 'empty.txt'), '');
+    writeFileSync(join(dir, "empty.txt"), "");
     const ops = new FileSystemOps(sandboxPolicyFor(dir));
 
-    const result = ops.readFileSafe({ path: 'empty.txt' });
+    const result = ops.readFileSafe({ path: "empty.txt" });
     expect(result.ok).toBe(true);
     if (!result.ok) return;
     // Empty file still has one "line" (the empty string before any newline)
     expect(result.value.content).toBeDefined();
   });
 
-  test('write empty content creates empty file', () => {
+  test("write empty content creates empty file", () => {
     const dir = makeTempDir();
     const ops = new FileSystemOps(sandboxPolicyFor(dir));
 
-    const result = ops.writeFileSafe({ path: 'empty.txt', content: '' });
+    const result = ops.writeFileSafe({ path: "empty.txt", content: "" });
     expect(result.ok).toBe(true);
     if (!result.ok) return;
     expect(result.value.isNewFile).toBe(true);
-    expect(readFileSync(join(dir, 'empty.txt'), 'utf-8')).toBe('');
+    expect(readFileSync(join(dir, "empty.txt"), "utf-8")).toBe("");
   });
 
-  test('edit on empty file returns MATCH_NOT_FOUND', () => {
+  test("edit on empty file returns MATCH_NOT_FOUND", () => {
     const dir = makeTempDir();
-    writeFileSync(join(dir, 'empty.txt'), '');
+    writeFileSync(join(dir, "empty.txt"), "");
     const ops = new FileSystemOps(sandboxPolicyFor(dir));
 
     const result = ops.editFileSafe({
-      path: 'empty.txt',
-      oldString: 'something',
-      newString: 'else',
+      path: "empty.txt",
+      oldString: "something",
+      newString: "else",
       replaceAll: false,
     });
     expect(result.ok).toBe(false);
     if (result.ok) return;
-    expect(result.error.code).toBe('MATCH_NOT_FOUND');
+    expect(result.error.code).toBe("MATCH_NOT_FOUND");
   });
 });
 
@@ -467,54 +490,57 @@ describe('FileSystemOps empty file operations', () => {
 // FileSystemOps: container /workspace path remapping
 // ===========================================================================
 
-describe('FileSystemOps /workspace path remapping', () => {
-  test('read remaps /workspace/ path to boundary', () => {
+describe("FileSystemOps /workspace path remapping", () => {
+  test("read remaps /workspace/ path to boundary", () => {
     const dir = makeTempDir();
-    writeFileSync(join(dir, 'file.txt'), 'workspace content');
+    writeFileSync(join(dir, "file.txt"), "workspace content");
     const ops = new FileSystemOps(sandboxPolicyFor(dir));
 
-    const result = ops.readFileSafe({ path: '/workspace/file.txt' });
+    const result = ops.readFileSafe({ path: "/workspace/file.txt" });
     expect(result.ok).toBe(true);
     if (!result.ok) return;
-    expect(result.value.content).toContain('workspace content');
+    expect(result.value.content).toContain("workspace content");
   });
 
-  test('write remaps /workspace/ path to boundary', () => {
+  test("write remaps /workspace/ path to boundary", () => {
     const dir = makeTempDir();
     const ops = new FileSystemOps(sandboxPolicyFor(dir));
 
-    const result = ops.writeFileSafe({ path: '/workspace/new.txt', content: 'remapped' });
+    const result = ops.writeFileSafe({
+      path: "/workspace/new.txt",
+      content: "remapped",
+    });
     expect(result.ok).toBe(true);
     if (!result.ok) return;
-    expect(existsSync(join(dir, 'new.txt'))).toBe(true);
-    expect(readFileSync(join(dir, 'new.txt'), 'utf-8')).toBe('remapped');
+    expect(existsSync(join(dir, "new.txt"))).toBe(true);
+    expect(readFileSync(join(dir, "new.txt"), "utf-8")).toBe("remapped");
   });
 
-  test('edit remaps /workspace/ path to boundary', () => {
+  test("edit remaps /workspace/ path to boundary", () => {
     const dir = makeTempDir();
-    writeFileSync(join(dir, 'file.txt'), 'old content');
+    writeFileSync(join(dir, "file.txt"), "old content");
     const ops = new FileSystemOps(sandboxPolicyFor(dir));
 
     const result = ops.editFileSafe({
-      path: '/workspace/file.txt',
-      oldString: 'old content',
-      newString: 'new content',
+      path: "/workspace/file.txt",
+      oldString: "old content",
+      newString: "new content",
       replaceAll: false,
     });
     expect(result.ok).toBe(true);
     if (!result.ok) return;
-    expect(result.value.newContent).toBe('new content');
-    expect(readFileSync(join(dir, 'file.txt'), 'utf-8')).toBe('new content');
+    expect(result.value.newContent).toBe("new content");
+    expect(readFileSync(join(dir, "file.txt"), "utf-8")).toBe("new content");
   });
 
-  test('/workspace traversal escape is blocked', () => {
+  test("/workspace traversal escape is blocked", () => {
     const dir = makeTempDir();
     const ops = new FileSystemOps(sandboxPolicyFor(dir));
 
-    const result = ops.readFileSafe({ path: '/workspace/../../../etc/passwd' });
+    const result = ops.readFileSafe({ path: "/workspace/../../../etc/passwd" });
     expect(result.ok).toBe(false);
     if (result.ok) return;
-    expect(result.error.code).toBe('PATH_OUT_OF_BOUNDS');
+    expect(result.error.code).toBe("PATH_OUT_OF_BOUNDS");
   });
 });
 
@@ -522,59 +548,62 @@ describe('FileSystemOps /workspace path remapping', () => {
 // FileSystemOps: custom size limit enforcement
 // ===========================================================================
 
-describe('FileSystemOps custom size limit', () => {
-  test('read rejects file exceeding custom limit', () => {
+describe("FileSystemOps custom size limit", () => {
+  test("read rejects file exceeding custom limit", () => {
     const dir = makeTempDir();
-    writeFileSync(join(dir, 'big.txt'), 'x'.repeat(500));
+    writeFileSync(join(dir, "big.txt"), "x".repeat(500));
     const ops = new FileSystemOps(sandboxPolicyFor(dir), { sizeLimit: 100 });
 
-    const result = ops.readFileSafe({ path: 'big.txt' });
+    const result = ops.readFileSafe({ path: "big.txt" });
     expect(result.ok).toBe(false);
     if (result.ok) return;
-    expect(result.error.code).toBe('SIZE_LIMIT_EXCEEDED');
+    expect(result.error.code).toBe("SIZE_LIMIT_EXCEEDED");
   });
 
-  test('read accepts file within custom limit', () => {
+  test("read accepts file within custom limit", () => {
     const dir = makeTempDir();
-    writeFileSync(join(dir, 'small.txt'), 'x'.repeat(50));
+    writeFileSync(join(dir, "small.txt"), "x".repeat(50));
     const ops = new FileSystemOps(sandboxPolicyFor(dir), { sizeLimit: 100 });
 
-    const result = ops.readFileSafe({ path: 'small.txt' });
+    const result = ops.readFileSafe({ path: "small.txt" });
     expect(result.ok).toBe(true);
   });
 
-  test('write rejects content exceeding custom limit', () => {
+  test("write rejects content exceeding custom limit", () => {
     const dir = makeTempDir();
     const ops = new FileSystemOps(sandboxPolicyFor(dir), { sizeLimit: 100 });
 
-    const result = ops.writeFileSafe({ path: 'big.txt', content: 'x'.repeat(500) });
+    const result = ops.writeFileSafe({
+      path: "big.txt",
+      content: "x".repeat(500),
+    });
     expect(result.ok).toBe(false);
     if (result.ok) return;
-    expect(result.error.code).toBe('SIZE_LIMIT_EXCEEDED');
+    expect(result.error.code).toBe("SIZE_LIMIT_EXCEEDED");
   });
 
-  test('edit rejects file exceeding custom limit', () => {
+  test("edit rejects file exceeding custom limit", () => {
     const dir = makeTempDir();
-    writeFileSync(join(dir, 'big.txt'), 'x'.repeat(500));
+    writeFileSync(join(dir, "big.txt"), "x".repeat(500));
     const ops = new FileSystemOps(sandboxPolicyFor(dir), { sizeLimit: 100 });
 
     const result = ops.editFileSafe({
-      path: 'big.txt',
-      oldString: 'x',
-      newString: 'y',
+      path: "big.txt",
+      oldString: "x",
+      newString: "y",
       replaceAll: false,
     });
     expect(result.ok).toBe(false);
     if (result.ok) return;
-    expect(result.error.code).toBe('SIZE_LIMIT_EXCEEDED');
+    expect(result.error.code).toBe("SIZE_LIMIT_EXCEEDED");
   });
 
-  test('no size limit when not specified (defaults to 100MB)', () => {
+  test("no size limit when not specified (defaults to 100MB)", () => {
     const dir = makeTempDir();
-    writeFileSync(join(dir, 'file.txt'), 'x'.repeat(1000));
+    writeFileSync(join(dir, "file.txt"), "x".repeat(1000));
     const ops = new FileSystemOps(sandboxPolicyFor(dir));
 
-    const result = ops.readFileSafe({ path: 'file.txt' });
+    const result = ops.readFileSafe({ path: "file.txt" });
     expect(result.ok).toBe(true);
   });
 });