@dexto/tools-filesystem 1.5.2 → 1.5.4

package/dist/write-file-tool.test.js

@@ -0,0 +1,194 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import * as path from "node:path";
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import { createWriteFileTool } from "./write-file-tool.js";
+import { FileSystemService } from "./filesystem-service.js";
+import { ToolErrorCode } from "@dexto/core";
+import { DextoRuntimeError } from "@dexto/core";
+const createMockLogger = () => ({
+  debug: vi.fn(),
+  info: vi.fn(),
+  warn: vi.fn(),
+  error: vi.fn(),
+  createChild: vi.fn().mockReturnThis()
+});
+describe("write_file tool", () => {
+  let mockLogger;
+  let tempDir;
+  let fileSystemService;
+  beforeEach(async () => {
+    mockLogger = createMockLogger();
+    const rawTempDir = await fs.mkdtemp(path.join(os.tmpdir(), "dexto-write-test-"));
+    tempDir = await fs.realpath(rawTempDir);
+    fileSystemService = new FileSystemService(
+      {
+        allowedPaths: [tempDir],
+        blockedPaths: [],
+        blockedExtensions: [],
+        maxFileSize: 10 * 1024 * 1024,
+        workingDirectory: tempDir,
+        enableBackups: false,
+        backupRetentionDays: 7
+      },
+      mockLogger
+    );
+    await fileSystemService.initialize();
+    vi.clearAllMocks();
+  });
+  afterEach(async () => {
+    try {
+      await fs.rm(tempDir, { recursive: true, force: true });
+    } catch {
+    }
+  });
+  describe("File Modification Detection - Existing Files", () => {
+    it("should succeed when existing file is not modified between preview and execute", async () => {
+      const tool = createWriteFileTool({ fileSystemService });
+      const testFile = path.join(tempDir, "test.txt");
+      await fs.writeFile(testFile, "original content");
+      const toolCallId = "test-call-123";
+      const input = {
+        file_path: testFile,
+        content: "new content"
+      };
+      const preview = await tool.generatePreview(input, { toolCallId });
+      expect(preview).toBeDefined();
+      expect(preview?.type).toBe("diff");
+      const result = await tool.execute(input, { toolCallId });
+      expect(result.success).toBe(true);
+      expect(result.path).toBe(testFile);
+      const content = await fs.readFile(testFile, "utf-8");
+      expect(content).toBe("new content");
+    });
+    it("should fail when existing file is modified between preview and execute", async () => {
+      const tool = createWriteFileTool({ fileSystemService });
+      const testFile = path.join(tempDir, "test.txt");
+      await fs.writeFile(testFile, "original content");
+      const toolCallId = "test-call-456";
+      const input = {
+        file_path: testFile,
+        content: "new content"
+      };
+      await tool.generatePreview(input, { toolCallId });
+      await fs.writeFile(testFile, "user modified this");
+      try {
+        await tool.execute(input, { toolCallId });
+        expect.fail("Should have thrown an error");
+      } catch (error) {
+        expect(error).toBeInstanceOf(DextoRuntimeError);
+        expect(error.code).toBe(
+          ToolErrorCode.FILE_MODIFIED_SINCE_PREVIEW
+        );
+      }
+      const content = await fs.readFile(testFile, "utf-8");
+      expect(content).toBe("user modified this");
+    });
+    it("should fail when existing file is deleted between preview and execute", async () => {
+      const tool = createWriteFileTool({ fileSystemService });
+      const testFile = path.join(tempDir, "test.txt");
+      await fs.writeFile(testFile, "original content");
+      const toolCallId = "test-call-deleted";
+      const input = {
+        file_path: testFile,
+        content: "new content"
+      };
+      await tool.generatePreview(input, { toolCallId });
+      await fs.unlink(testFile);
+      try {
+        await tool.execute(input, { toolCallId });
+        expect.fail("Should have thrown an error");
+      } catch (error) {
+        expect(error).toBeInstanceOf(DextoRuntimeError);
+        expect(error.code).toBe(
+          ToolErrorCode.FILE_MODIFIED_SINCE_PREVIEW
+        );
+      }
+    });
+  });
+  describe("File Modification Detection - New Files", () => {
+    it("should succeed when creating new file that still does not exist", async () => {
+      const tool = createWriteFileTool({ fileSystemService });
+      const testFile = path.join(tempDir, "new-file.txt");
+      const toolCallId = "test-call-new";
+      const input = {
+        file_path: testFile,
+        content: "brand new content"
+      };
+      const preview = await tool.generatePreview(input, { toolCallId });
+      expect(preview).toBeDefined();
+      expect(preview?.type).toBe("file");
+      expect(preview.operation).toBe("create");
+      const result = await tool.execute(input, { toolCallId });
+      expect(result.success).toBe(true);
+      const content = await fs.readFile(testFile, "utf-8");
+      expect(content).toBe("brand new content");
+    });
+    it("should fail when file is created by someone else between preview and execute", async () => {
+      const tool = createWriteFileTool({ fileSystemService });
+      const testFile = path.join(tempDir, "race-condition.txt");
+      const toolCallId = "test-call-race";
+      const input = {
+        file_path: testFile,
+        content: "agent content"
+      };
+      const preview = await tool.generatePreview(input, { toolCallId });
+      expect(preview?.type).toBe("file");
+      await fs.writeFile(testFile, "someone else created this");
+      try {
+        await tool.execute(input, { toolCallId });
+        expect.fail("Should have thrown an error");
+      } catch (error) {
+        expect(error).toBeInstanceOf(DextoRuntimeError);
+        expect(error.code).toBe(
+          ToolErrorCode.FILE_MODIFIED_SINCE_PREVIEW
+        );
+      }
+      const content = await fs.readFile(testFile, "utf-8");
+      expect(content).toBe("someone else created this");
+    });
+  });
+  describe("Cache Cleanup", () => {
+    it("should clean up hash cache after successful execution", async () => {
+      const tool = createWriteFileTool({ fileSystemService });
+      const testFile = path.join(tempDir, "test.txt");
+      await fs.writeFile(testFile, "original");
+      const toolCallId = "test-call-cleanup";
+      const input = {
+        file_path: testFile,
+        content: "first write"
+      };
+      await tool.generatePreview(input, { toolCallId });
+      await tool.execute(input, { toolCallId });
+      const input2 = {
+        file_path: testFile,
+        content: "second write"
+      };
+      await tool.generatePreview(input2, { toolCallId });
+      const result = await tool.execute(input2, { toolCallId });
+      expect(result.success).toBe(true);
+      const content = await fs.readFile(testFile, "utf-8");
+      expect(content).toBe("second write");
+    });
+    it("should clean up hash cache after failed execution", async () => {
+      const tool = createWriteFileTool({ fileSystemService });
+      const testFile = path.join(tempDir, "test.txt");
+      await fs.writeFile(testFile, "original");
+      const toolCallId = "test-call-fail";
+      const input = {
+        file_path: testFile,
+        content: "new content"
+      };
+      await tool.generatePreview(input, { toolCallId });
+      await fs.writeFile(testFile, "modified");
+      try {
+        await tool.execute(input, { toolCallId });
+      } catch {
+      }
+      await fs.writeFile(testFile, "reset content");
+      await tool.generatePreview(input, { toolCallId });
+      const result = await tool.execute(input, { toolCallId });
+      expect(result.success).toBe(true);
+    });
+  });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dexto/tools-filesystem",
-  "version": "1.5.2",
+  "version": "1.5.4",
   "description": "FileSystem tools provider for Dexto agents",
   "type": "module",
   "main": "./dist/index.js",
@@ -22,7 +22,7 @@
     "glob": "^11.1.0",
     "safe-regex": "^2.1.1",
     "zod": "^3.25.0",
-    "@dexto/core": "1.5.2"
+    "@dexto/core": "1.5.4"
   },
   "devDependencies": {
     "@types/diff": "^5.2.3",