@dexto/tools-filesystem 1.5.1 → 1.5.3

package/dist/write-file-tool.js

@@ -1,8 +1,18 @@
 import * as path from "node:path";
+import { createHash } from "node:crypto";
 import { z } from "zod";
 import { createPatch } from "diff";
-import { DextoRuntimeError, ApprovalType } from "@dexto/core";
+import {
+  DextoRuntimeError,
+  ApprovalType,
+  ToolError
+} from "@dexto/core";
 import { FileSystemErrorCode } from "./error-codes.js";
+const previewContentHashCache = /* @__PURE__ */ new Map();
+const FILE_NOT_EXISTS_MARKER = null;
+function computeContentHash(content) {
+  return createHash("sha256").update(content, "utf8").digest("hex");
+}
 const WriteFileInputSchema = z.object({
   file_path: z.string().describe("Absolute path where the file should be written"),
   content: z.string().describe("Content to write to the file"),
@@ -34,10 +44,10 @@ function createWriteFileTool(options) {
      * Check if this write operation needs directory access approval.
      * Returns custom approval request if the file is outside allowed paths.
      */
-    getApprovalOverride: (args) => {
+    getApprovalOverride: async (args) => {
       const { file_path } = args;
       if (!file_path) return null;
-      const isAllowed = fileSystemService.isPathWithinConfigAllowed(file_path);
+      const isAllowed = await fileSystemService.isPathWithinConfigAllowed(file_path);
       if (isAllowed) {
         return null;
       }
@@ -72,15 +82,25 @@ function createWriteFileTool(options) {
     },
     /**
      * Generate preview for approval UI - shows diff or file creation info
+     * Stores content hash for change detection in execute phase.
      */
-    generatePreview: async (input, _context) => {
+    generatePreview: async (input, context) => {
       const { file_path, content } = input;
       try {
         const originalFile = await fileSystemService.readFile(file_path);
         const originalContent = originalFile.content;
+        if (context?.toolCallId) {
+          previewContentHashCache.set(
+            context.toolCallId,
+            computeContentHash(originalContent)
+          );
+        }
         return generateDiffPreview(file_path, originalContent, content);
       } catch (error) {
         if (error instanceof DextoRuntimeError && error.code === FileSystemErrorCode.FILE_NOT_FOUND) {
+          if (context?.toolCallId) {
+            previewContentHashCache.set(context.toolCallId, FILE_NOT_EXISTS_MARKER);
+          }
           const lineCount = content.split("\n").length;
           const preview = {
             type: "file",
@@ -96,24 +116,42 @@ function createWriteFileTool(options) {
         throw error;
       }
     },
-    execute: async (input, _context) => {
+    execute: async (input, context) => {
       const { file_path, content, create_dirs, encoding } = input;
       let originalContent = null;
+      let fileExistsNow = false;
       try {
         const originalFile = await fileSystemService.readFile(file_path);
         originalContent = originalFile.content;
+        fileExistsNow = true;
       } catch (error) {
         if (error instanceof DextoRuntimeError && error.code === FileSystemErrorCode.FILE_NOT_FOUND) {
           originalContent = null;
+          fileExistsNow = false;
         } else {
           throw error;
         }
       }
+      if (context?.toolCallId && previewContentHashCache.has(context.toolCallId)) {
+        const expectedHash = previewContentHashCache.get(context.toolCallId);
+        previewContentHashCache.delete(context.toolCallId);
+        if (expectedHash === FILE_NOT_EXISTS_MARKER) {
+          if (fileExistsNow) {
+            throw ToolError.fileModifiedSincePreview("write_file", file_path);
+          }
+        } else if (expectedHash !== null) {
+          if (!fileExistsNow) {
+            throw ToolError.fileModifiedSincePreview("write_file", file_path);
+          }
+          const currentHash = computeContentHash(originalContent);
+          if (expectedHash !== currentHash) {
+            throw ToolError.fileModifiedSincePreview("write_file", file_path);
+          }
+        }
+      }
       const result = await fileSystemService.writeFile(file_path, content, {
         createDirs: create_dirs,
-        encoding,
-        backup: true
-        // Always create backup for internal tools
+        encoding
       });
       let _display;
       if (originalContent === null) {

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

@@ -0,0 +1,217 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var import_vitest = require("vitest");
+var path = __toESM(require("node:path"), 1);
+var fs = __toESM(require("node:fs/promises"), 1);
+var os = __toESM(require("node:os"), 1);
+var import_write_file_tool = require("./write-file-tool.js");
+var import_filesystem_service = require("./filesystem-service.js");
+var import_core = require("@dexto/core");
+var import_core2 = require("@dexto/core");
+const createMockLogger = () => ({
+  debug: import_vitest.vi.fn(),
+  info: import_vitest.vi.fn(),
+  warn: import_vitest.vi.fn(),
+  error: import_vitest.vi.fn(),
+  createChild: import_vitest.vi.fn().mockReturnThis()
+});
+(0, import_vitest.describe)("write_file tool", () => {
+  let mockLogger;
+  let tempDir;
+  let fileSystemService;
+  (0, import_vitest.beforeEach)(async () => {
+    mockLogger = createMockLogger();
+    const rawTempDir = await fs.mkdtemp(path.join(os.tmpdir(), "dexto-write-test-"));
+    tempDir = await fs.realpath(rawTempDir);
+    fileSystemService = new import_filesystem_service.FileSystemService(
+      {
+        allowedPaths: [tempDir],
+        blockedPaths: [],
+        blockedExtensions: [],
+        maxFileSize: 10 * 1024 * 1024,
+        workingDirectory: tempDir,
+        enableBackups: false,
+        backupRetentionDays: 7
+      },
+      mockLogger
+    );
+    await fileSystemService.initialize();
+    import_vitest.vi.clearAllMocks();
+  });
+  (0, import_vitest.afterEach)(async () => {
+    try {
+      await fs.rm(tempDir, { recursive: true, force: true });
+    } catch {
+    }
+  });
+  (0, import_vitest.describe)("File Modification Detection - Existing Files", () => {
+    (0, import_vitest.it)("should succeed when existing file is not modified between preview and execute", async () => {
+      const tool = (0, import_write_file_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 });
+      (0, import_vitest.expect)(preview).toBeDefined();
+      (0, import_vitest.expect)(preview?.type).toBe("diff");
+      const result = await tool.execute(input, { toolCallId });
+      (0, import_vitest.expect)(result.success).toBe(true);
+      (0, import_vitest.expect)(result.path).toBe(testFile);
+      const content = await fs.readFile(testFile, "utf-8");
+      (0, import_vitest.expect)(content).toBe("new content");
+    });
+    (0, import_vitest.it)("should fail when existing file is modified between preview and execute", async () => {
+      const tool = (0, import_write_file_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 });
+        import_vitest.expect.fail("Should have thrown an error");
+      } catch (error) {
+        (0, import_vitest.expect)(error).toBeInstanceOf(import_core2.DextoRuntimeError);
+        (0, import_vitest.expect)(error.code).toBe(
+          import_core.ToolErrorCode.FILE_MODIFIED_SINCE_PREVIEW
+        );
+      }
+      const content = await fs.readFile(testFile, "utf-8");
+      (0, import_vitest.expect)(content).toBe("user modified this");
+    });
+    (0, import_vitest.it)("should fail when existing file is deleted between preview and execute", async () => {
+      const tool = (0, import_write_file_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 });
+        import_vitest.expect.fail("Should have thrown an error");
+      } catch (error) {
+        (0, import_vitest.expect)(error).toBeInstanceOf(import_core2.DextoRuntimeError);
+        (0, import_vitest.expect)(error.code).toBe(
+          import_core.ToolErrorCode.FILE_MODIFIED_SINCE_PREVIEW
+        );
+      }
+    });
+  });
+  (0, import_vitest.describe)("File Modification Detection - New Files", () => {
+    (0, import_vitest.it)("should succeed when creating new file that still does not exist", async () => {
+      const tool = (0, import_write_file_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 });
+      (0, import_vitest.expect)(preview).toBeDefined();
+      (0, import_vitest.expect)(preview?.type).toBe("file");
+      (0, import_vitest.expect)(preview.operation).toBe("create");
+      const result = await tool.execute(input, { toolCallId });
+      (0, import_vitest.expect)(result.success).toBe(true);
+      const content = await fs.readFile(testFile, "utf-8");
+      (0, import_vitest.expect)(content).toBe("brand new content");
+    });
+    (0, import_vitest.it)("should fail when file is created by someone else between preview and execute", async () => {
+      const tool = (0, import_write_file_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 });
+      (0, import_vitest.expect)(preview?.type).toBe("file");
+      await fs.writeFile(testFile, "someone else created this");
+      try {
+        await tool.execute(input, { toolCallId });
+        import_vitest.expect.fail("Should have thrown an error");
+      } catch (error) {
+        (0, import_vitest.expect)(error).toBeInstanceOf(import_core2.DextoRuntimeError);
+        (0, import_vitest.expect)(error.code).toBe(
+          import_core.ToolErrorCode.FILE_MODIFIED_SINCE_PREVIEW
+        );
+      }
+      const content = await fs.readFile(testFile, "utf-8");
+      (0, import_vitest.expect)(content).toBe("someone else created this");
+    });
+  });
+  (0, import_vitest.describe)("Cache Cleanup", () => {
+    (0, import_vitest.it)("should clean up hash cache after successful execution", async () => {
+      const tool = (0, import_write_file_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 });
+      (0, import_vitest.expect)(result.success).toBe(true);
+      const content = await fs.readFile(testFile, "utf-8");
+      (0, import_vitest.expect)(content).toBe("second write");
+    });
+    (0, import_vitest.it)("should clean up hash cache after failed execution", async () => {
+      const tool = (0, import_write_file_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 });
+      (0, import_vitest.expect)(result.success).toBe(true);
+    });
+  });
+});

package/dist/write-file-tool.test.d.cts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/write-file-tool.test.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

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.1",
+  "version": "1.5.3",
   "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.1"
+    "@dexto/core": "1.5.3"
   },
   "devDependencies": {
     "@types/diff": "^5.2.3",