@dexto/tools-filesystem 1.5.8 → 1.6.1

package/dist/edit-file-tool.js

@@ -1,18 +1,22 @@
-import * as path from "node:path";
 import { createHash } from "node:crypto";
 import { z } from "zod";
 import { createPatch } from "diff";
-import { ApprovalType } from "@dexto/core";
-import { ToolError } from "@dexto/core";
-import { ToolErrorCode } from "@dexto/core";
-import { DextoRuntimeError } from "@dexto/core";
+import {
+  createLocalToolCallHeader,
+  DextoRuntimeError,
+  ToolError,
+  ToolErrorCode,
+  defineTool,
+  truncateForHeader
+} from "@dexto/core";
 import { FileSystemErrorCode } from "./error-codes.js";
+import { createDirectoryAccessApprovalHandlers, resolveFilePath } from "./directory-approval.js";
 const previewContentHashCache = /* @__PURE__ */ new Map();
 function computeContentHash(content) {
   return createHash("sha256").update(content, "utf8").digest("hex");
 }
 const EditFileInputSchema = z.object({
-  file_path: z.string().describe("Absolute path to the file to edit"),
+  file_path: z.string().min(1).describe("Absolute path to the file to edit"),
   old_string: z.string().describe("Text to replace (must be unique unless replace_all is true)"),
   new_string: z.string().describe("Replacement text"),
   replace_all: z.boolean().optional().default(false).describe("Replace all occurrences (default: false, requires unique match)")
@@ -25,134 +29,136 @@ function generateDiffPreview(filePath, originalContent, newContent) {
   const deletions = (unified.match(/^-[^-]/gm) || []).length;
   return {
     type: "diff",
+    title: "Update file",
     unified,
     filename: filePath,
     additions,
     deletions
   };
 }
-function createEditFileTool(options) {
-  const { fileSystemService, directoryApproval } = options;
-  let pendingApprovalParentDir;
-  return {
+function createEditFileTool(getFileSystemService) {
+  return defineTool({
     id: "edit_file",
+    aliases: ["edit"],
     description: "Edit a file by replacing text. By default, old_string must be unique in the file (will error if found multiple times). Set replace_all=true to replace all occurrences. Automatically creates backup before editing. Requires approval. Returns success status, path, number of changes made, and backup path.",
     inputSchema: EditFileInputSchema,
-    /**
-     * Check if this edit operation needs directory access approval.
-     * Returns custom approval request if the file is outside allowed paths.
-     */
-    getApprovalOverride: async (args) => {
-      const { file_path } = args;
-      if (!file_path) return null;
-      const isAllowed = await fileSystemService.isPathWithinConfigAllowed(file_path);
-      if (isAllowed) {
-        return null;
-      }
-      if (directoryApproval?.isSessionApproved(file_path)) {
-        return null;
-      }
-      const absolutePath = path.resolve(file_path);
-      const parentDir = path.dirname(absolutePath);
-      pendingApprovalParentDir = parentDir;
-      return {
-        type: ApprovalType.DIRECTORY_ACCESS,
-        metadata: {
-          path: absolutePath,
-          parentDir,
-          operation: "edit",
-          toolName: "edit_file"
-        }
-      };
-    },
-    /**
-     * Handle approved directory access - remember the directory for session
-     */
-    onApprovalGranted: (response) => {
-      if (!directoryApproval || !pendingApprovalParentDir) return;
-      const data = response.data;
-      const rememberDirectory = data?.rememberDirectory ?? false;
-      directoryApproval.addApproved(
-        pendingApprovalParentDir,
-        rememberDirectory ? "session" : "once"
-      );
-      pendingApprovalParentDir = void 0;
-    },
-    /**
-     * Generate preview for approval UI - shows diff without modifying file
-     * Throws ToolError.validationFailed() for validation errors (file not found, string not found)
-     * Stores content hash for change detection in execute phase.
-     */
-    generatePreview: async (input, context) => {
-      const { file_path, old_string, new_string, replace_all } = input;
-      try {
-        const originalFile = await fileSystemService.readFile(file_path);
-        const originalContent = originalFile.content;
-        if (context?.toolCallId) {
-          previewContentHashCache.set(
-            context.toolCallId,
-            computeContentHash(originalContent)
-          );
-        }
-        if (!replace_all) {
-          const occurrences = originalContent.split(old_string).length - 1;
-          if (occurrences > 1) {
+    ...createDirectoryAccessApprovalHandlers({
+      toolName: "edit_file",
+      operation: "edit",
+      inputSchema: EditFileInputSchema,
+      getFileSystemService,
+      resolvePaths: (input, fileSystemService) => resolveFilePath(fileSystemService.getWorkingDirectory(), input.file_path)
+    }),
+    presentation: {
+      describeHeader: (input) => createLocalToolCallHeader({
+        title: "Update",
+        argsText: truncateForHeader(input.file_path, 140)
+      }),
+      /**
+       * Generate preview for approval UI - shows diff without modifying file
+       * Throws ToolError.validationFailed() for validation errors (file not found, string not found)
+       * Stores content hash for change detection in execute phase.
+       */
+      preview: async (input, context) => {
+        const { file_path, old_string, new_string, replace_all } = input;
+        const resolvedFileSystemService = await getFileSystemService(context);
+        const { path: resolvedPath } = resolveFilePath(
+          resolvedFileSystemService.getWorkingDirectory(),
+          file_path
+        );
+        try {
+          let originalContent;
+          try {
+            const originalFile = await resolvedFileSystemService.readFile(resolvedPath);
+            originalContent = originalFile.content;
+          } catch (error) {
+            if (error instanceof DextoRuntimeError && error.code === FileSystemErrorCode.INVALID_PATH) {
+              const originalFile = await resolvedFileSystemService.readFileForToolPreview(
+                resolvedPath
+              );
+              originalContent = originalFile.content;
+            } else {
+              throw error;
+            }
+          }
+          if (context.toolCallId) {
+            previewContentHashCache.set(
+              context.toolCallId,
+              computeContentHash(originalContent)
+            );
+          }
+          if (!replace_all) {
+            const occurrences = originalContent.split(old_string).length - 1;
+            if (occurrences > 1) {
+              throw ToolError.validationFailed(
+                "edit_file",
+                `String found ${occurrences} times in file. Set replace_all=true to replace all, or provide more context to make old_string unique.`,
+                { file_path: resolvedPath, occurrences }
+              );
+            }
+          }
+          const newContent = replace_all ? originalContent.split(old_string).join(new_string) : originalContent.replace(old_string, new_string);
+          if (originalContent === newContent) {
             throw ToolError.validationFailed(
               "edit_file",
-              `String found ${occurrences} times in file. Set replace_all=true to replace all, or provide more context to make old_string unique.`,
-              { file_path, occurrences }
+              `String not found in file: "${old_string.slice(0, 50)}${old_string.length > 50 ? "..." : ""}"`,
+              {
+                file_path: resolvedPath,
+                old_string_preview: old_string.slice(0, 100)
+              }
             );
           }
+          return generateDiffPreview(resolvedPath, originalContent, newContent);
+        } catch (error) {
+          if (error instanceof DextoRuntimeError && error.code === ToolErrorCode.VALIDATION_FAILED) {
+            throw error;
+          }
+          if (error instanceof DextoRuntimeError) {
+            throw ToolError.validationFailed("edit_file", error.message, {
+              file_path: resolvedPath,
+              originalErrorCode: error.code
+            });
+          }
+          return null;
         }
-        const newContent = replace_all ? originalContent.split(old_string).join(new_string) : originalContent.replace(old_string, new_string);
-        if (originalContent === newContent) {
-          throw ToolError.validationFailed(
-            "edit_file",
-            `String not found in file: "${old_string.slice(0, 50)}${old_string.length > 50 ? "..." : ""}"`,
-            { file_path, old_string_preview: old_string.slice(0, 100) }
-          );
-        }
-        return generateDiffPreview(file_path, originalContent, newContent);
-      } catch (error) {
-        if (error instanceof DextoRuntimeError && error.code === ToolErrorCode.VALIDATION_FAILED) {
-          throw error;
-        }
-        if (error instanceof DextoRuntimeError) {
-          throw ToolError.validationFailed("edit_file", error.message, {
-            file_path,
-            originalErrorCode: error.code
-          });
-        }
-        return null;
       }
     },
-    execute: async (input, context) => {
+    async execute(input, context) {
+      const resolvedFileSystemService = await getFileSystemService(context);
       const { file_path, old_string, new_string, replace_all } = input;
-      if (context?.toolCallId && previewContentHashCache.has(context.toolCallId)) {
-        const expectedHash = previewContentHashCache.get(context.toolCallId);
-        previewContentHashCache.delete(context.toolCallId);
-        let currentContent;
-        try {
-          const currentFile = await fileSystemService.readFile(file_path);
-          currentContent = currentFile.content;
-        } catch (error) {
-          if (error instanceof DextoRuntimeError && error.code === FileSystemErrorCode.FILE_NOT_FOUND) {
-            throw ToolError.fileModifiedSincePreview("edit_file", file_path);
+      const { path: resolvedPath } = resolveFilePath(
+        resolvedFileSystemService.getWorkingDirectory(),
+        file_path
+      );
+      const toolCallId = context.toolCallId;
+      if (toolCallId) {
+        const expectedHash = previewContentHashCache.get(toolCallId);
+        if (expectedHash === void 0) {
+        } else {
+          previewContentHashCache.delete(toolCallId);
+          let currentContent;
+          try {
+            const currentFile = await resolvedFileSystemService.readFile(resolvedPath);
+            currentContent = currentFile.content;
+          } catch (error) {
+            if (error instanceof DextoRuntimeError && error.code === FileSystemErrorCode.FILE_NOT_FOUND) {
+              throw ToolError.fileModifiedSincePreview("edit_file", resolvedPath);
+            }
+            throw error;
+          }
+          const currentHash = computeContentHash(currentContent);
+          if (expectedHash !== currentHash) {
+            throw ToolError.fileModifiedSincePreview("edit_file", resolvedPath);
           }
-          throw error;
-        }
-        const currentHash = computeContentHash(currentContent);
-        if (expectedHash !== currentHash) {
-          throw ToolError.fileModifiedSincePreview("edit_file", file_path);
         }
       }
-      const result = await fileSystemService.editFile(file_path, {
+      const result = await resolvedFileSystemService.editFile(resolvedPath, {
         oldString: old_string,
         newString: new_string,
         replaceAll: replace_all
       });
       const _display = generateDiffPreview(
-        file_path,
+        resolvedPath,
         result.originalContent,
         result.newContent
       );
@@ -164,7 +170,7 @@ function createEditFileTool(options) {
         _display
       };
     }
-  };
+  });
 }
 export {
   createEditFileTool

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

@@ -29,13 +29,26 @@ var import_edit_file_tool = require("./edit-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()
-});
+const createMockLogger = () => {
+  const logger = {
+    debug: import_vitest.vi.fn(),
+    silly: import_vitest.vi.fn(),
+    info: import_vitest.vi.fn(),
+    warn: import_vitest.vi.fn(),
+    error: import_vitest.vi.fn(),
+    trackException: import_vitest.vi.fn(),
+    createChild: import_vitest.vi.fn(() => logger),
+    createFileOnlyChild: import_vitest.vi.fn(() => logger),
+    setLevel: import_vitest.vi.fn(),
+    getLevel: import_vitest.vi.fn(() => "debug"),
+    getLogFilePath: import_vitest.vi.fn(() => null),
+    destroy: import_vitest.vi.fn(async () => void 0)
+  };
+  return logger;
+};
+function createToolContext(logger, overrides = {}) {
+  return { logger, ...overrides };
+}
 (0, import_vitest.describe)("edit_file tool", () => {
   let mockLogger;
   let tempDir;
@@ -66,8 +79,43 @@ const createMockLogger = () => ({
     }
   });
   (0, import_vitest.describe)("File Modification Detection", () => {
+    (0, import_vitest.it)("should generate preview for files outside config-allowed roots (preview read only)", async () => {
+      const tool = (0, import_edit_file_tool.createEditFileTool)(async () => fileSystemService);
+      const previewFn = tool.presentation?.preview;
+      (0, import_vitest.expect)(previewFn).toBeDefined();
+      const rawExternalDir = await fs.mkdtemp(
+        path.join(os.tmpdir(), "dexto-edit-outside-allowed-")
+      );
+      const externalDir = await fs.realpath(rawExternalDir);
+      const externalFile = path.join(externalDir, "external.txt");
+      try {
+        await fs.writeFile(externalFile, "hello world");
+        const toolCallId = "preview-outside-roots";
+        const parsedInput = tool.inputSchema.parse({
+          file_path: externalFile,
+          old_string: "world",
+          new_string: "universe"
+        });
+        const preview = await previewFn(
+          parsedInput,
+          createToolContext(mockLogger, { toolCallId })
+        );
+        (0, import_vitest.expect)(preview).toBeDefined();
+        (0, import_vitest.expect)(preview?.type).toBe("diff");
+        if (preview?.type === "diff") {
+          (0, import_vitest.expect)(preview.title).toBe("Update file");
+          (0, import_vitest.expect)(preview.filename).toBe(externalFile);
+        } else {
+          import_vitest.expect.fail("Expected diff preview");
+        }
+      } finally {
+        await fs.rm(externalDir, { recursive: true, force: true });
+      }
+    });
     (0, import_vitest.it)("should succeed when file is not modified between preview and execute", async () => {
-      const tool = (0, import_edit_file_tool.createEditFileTool)({ fileSystemService });
+      const tool = (0, import_edit_file_tool.createEditFileTool)(async () => fileSystemService);
+      const previewFn = tool.presentation?.preview;
+      (0, import_vitest.expect)(previewFn).toBeDefined();
       const testFile = path.join(tempDir, "test.txt");
       await fs.writeFile(testFile, "hello world");
       const toolCallId = "test-call-123";
@@ -76,16 +124,25 @@ const createMockLogger = () => ({
         old_string: "world",
         new_string: "universe"
       };
-      const preview = await tool.generatePreview(input, { toolCallId });
+      const parsedInput = tool.inputSchema.parse(input);
+      const preview = await previewFn(
+        parsedInput,
+        createToolContext(mockLogger, { toolCallId })
+      );
       (0, import_vitest.expect)(preview).toBeDefined();
-      const result = await tool.execute(input, { toolCallId });
+      const result = await tool.execute(
+        parsedInput,
+        createToolContext(mockLogger, { 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("hello universe");
     });
     (0, import_vitest.it)("should fail when file is modified between preview and execute", async () => {
-      const tool = (0, import_edit_file_tool.createEditFileTool)({ fileSystemService });
+      const tool = (0, import_edit_file_tool.createEditFileTool)(async () => fileSystemService);
+      const previewFn = tool.presentation?.preview;
+      (0, import_vitest.expect)(previewFn).toBeDefined();
       const testFile = path.join(tempDir, "test.txt");
       await fs.writeFile(testFile, "hello world");
       const toolCallId = "test-call-456";
@@ -94,11 +151,15 @@ const createMockLogger = () => ({
         old_string: "world",
         new_string: "universe"
       };
-      const preview = await tool.generatePreview(input, { toolCallId });
+      const parsedInput = tool.inputSchema.parse(input);
+      const preview = await previewFn(
+        parsedInput,
+        createToolContext(mockLogger, { toolCallId })
+      );
       (0, import_vitest.expect)(preview).toBeDefined();
       await fs.writeFile(testFile, "hello world - user added this");
       try {
-        await tool.execute(input, { toolCallId });
+        await tool.execute(parsedInput, createToolContext(mockLogger, { toolCallId }));
         import_vitest.expect.fail("Should have thrown an error");
       } catch (error) {
         (0, import_vitest.expect)(error).toBeInstanceOf(import_core2.DextoRuntimeError);
@@ -110,7 +171,9 @@ const createMockLogger = () => ({
       (0, import_vitest.expect)(content).toBe("hello world - user added this");
     });
     (0, import_vitest.it)("should detect file modification with correct error code", async () => {
-      const tool = (0, import_edit_file_tool.createEditFileTool)({ fileSystemService });
+      const tool = (0, import_edit_file_tool.createEditFileTool)(async () => fileSystemService);
+      const previewFn = tool.presentation?.preview;
+      (0, import_vitest.expect)(previewFn).toBeDefined();
       const testFile = path.join(tempDir, "test.txt");
       await fs.writeFile(testFile, "hello world");
       const toolCallId = "test-call-789";
@@ -119,10 +182,11 @@ const createMockLogger = () => ({
         old_string: "world",
         new_string: "universe"
       };
-      await tool.generatePreview(input, { toolCallId });
+      const parsedInput = tool.inputSchema.parse(input);
+      await previewFn(parsedInput, createToolContext(mockLogger, { toolCallId }));
       await fs.writeFile(testFile, "hello world modified");
       try {
-        await tool.execute(input, { toolCallId });
+        await tool.execute(parsedInput, createToolContext(mockLogger, { toolCallId }));
         import_vitest.expect.fail("Should have thrown an error");
       } catch (error) {
         (0, import_vitest.expect)(error).toBeInstanceOf(import_core2.DextoRuntimeError);
@@ -136,7 +200,9 @@ const createMockLogger = () => ({
       }
     });
     (0, import_vitest.it)("should work without toolCallId (no modification check)", async () => {
-      const tool = (0, import_edit_file_tool.createEditFileTool)({ fileSystemService });
+      const tool = (0, import_edit_file_tool.createEditFileTool)(async () => fileSystemService);
+      const previewFn = tool.presentation?.preview;
+      (0, import_vitest.expect)(previewFn).toBeDefined();
       const testFile = path.join(tempDir, "test.txt");
       await fs.writeFile(testFile, "hello world");
       const input = {
@@ -144,10 +210,11 @@ const createMockLogger = () => ({
         old_string: "world",
         new_string: "universe"
       };
-      await tool.generatePreview(input, {});
+      const parsedInput = tool.inputSchema.parse(input);
+      await previewFn(parsedInput, createToolContext(mockLogger));
       await fs.writeFile(testFile, "hello world changed");
       try {
-        await tool.execute(input, {});
+        await tool.execute(parsedInput, createToolContext(mockLogger));
       } catch (error) {
         (0, import_vitest.expect)(error).toBeInstanceOf(import_core2.DextoRuntimeError);
         (0, import_vitest.expect)(error.code).not.toBe(
@@ -156,7 +223,9 @@ const createMockLogger = () => ({
       }
     });
     (0, import_vitest.it)("should clean up hash cache after successful execution", async () => {
-      const tool = (0, import_edit_file_tool.createEditFileTool)({ fileSystemService });
+      const tool = (0, import_edit_file_tool.createEditFileTool)(async () => fileSystemService);
+      const previewFn = tool.presentation?.preview;
+      (0, import_vitest.expect)(previewFn).toBeDefined();
       const testFile = path.join(tempDir, "test.txt");
       await fs.writeFile(testFile, "hello world");
       const toolCallId = "test-call-cleanup";
@@ -165,21 +234,28 @@ const createMockLogger = () => ({
         old_string: "world",
         new_string: "universe"
       };
-      await tool.generatePreview(input, { toolCallId });
-      await tool.execute(input, { toolCallId });
+      const parsedInput = tool.inputSchema.parse(input);
+      await previewFn(parsedInput, createToolContext(mockLogger, { toolCallId }));
+      await tool.execute(parsedInput, createToolContext(mockLogger, { toolCallId }));
       const input2 = {
         file_path: testFile,
         old_string: "universe",
         new_string: "galaxy"
       };
-      await tool.generatePreview(input2, { toolCallId });
-      const result = await tool.execute(input2, { toolCallId });
+      const parsedInput2 = tool.inputSchema.parse(input2);
+      await previewFn(parsedInput2, createToolContext(mockLogger, { toolCallId }));
+      const result = await tool.execute(
+        parsedInput2,
+        createToolContext(mockLogger, { toolCallId })
+      );
       (0, import_vitest.expect)(result.success).toBe(true);
       const content = await fs.readFile(testFile, "utf-8");
       (0, import_vitest.expect)(content).toBe("hello galaxy");
     });
     (0, import_vitest.it)("should clean up hash cache after failed execution", async () => {
-      const tool = (0, import_edit_file_tool.createEditFileTool)({ fileSystemService });
+      const tool = (0, import_edit_file_tool.createEditFileTool)(async () => fileSystemService);
+      const previewFn = tool.presentation?.preview;
+      (0, import_vitest.expect)(previewFn).toBeDefined();
       const testFile = path.join(tempDir, "test.txt");
       await fs.writeFile(testFile, "hello world");
       const toolCallId = "test-call-fail-cleanup";
@@ -188,15 +264,19 @@ const createMockLogger = () => ({
         old_string: "world",
         new_string: "universe"
       };
-      await tool.generatePreview(input, { toolCallId });
+      const parsedInput = tool.inputSchema.parse(input);
+      await previewFn(parsedInput, createToolContext(mockLogger, { toolCallId }));
       await fs.writeFile(testFile, "hello world modified");
       try {
-        await tool.execute(input, { toolCallId });
+        await tool.execute(parsedInput, createToolContext(mockLogger, { toolCallId }));
       } catch {
       }
       await fs.writeFile(testFile, "hello world");
-      await tool.generatePreview(input, { toolCallId });
-      const result = await tool.execute(input, { toolCallId });
+      await previewFn(parsedInput, createToolContext(mockLogger, { toolCallId }));
+      const result = await tool.execute(
+        parsedInput,
+        createToolContext(mockLogger, { toolCallId })
+      );
       (0, import_vitest.expect)(result.success).toBe(true);
     });
   });

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

@@ -1,2 +1,7 @@
-
-export {  }
+/**
+ * Edit File Tool Tests
+ *
+ * Tests for the edit_file tool including file modification detection.
+ */
+export {};
+//# sourceMappingURL=edit-file-tool.test.d.ts.map

package/dist/edit-file-tool.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edit-file-tool.test.d.ts","sourceRoot":"","sources":["../src/edit-file-tool.test.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}