@dexto/tools-filesystem 1.5.8 → 1.6.1

package/dist/directory-approval.integration.test.js

@@ -2,25 +2,52 @@ 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 {
+  ApprovalManager,
+  DextoRuntimeError
+} from "@dexto/core";
+import { FileSystemService } from "./filesystem-service.js";
 import { createReadFileTool } from "./read-file-tool.js";
 import { createWriteFileTool } from "./write-file-tool.js";
 import { createEditFileTool } from "./edit-file-tool.js";
-import { FileSystemService } from "./filesystem-service.js";
-import { ApprovalType, ApprovalStatus } from "@dexto/core";
-const createMockLogger = () => ({
-  debug: vi.fn(),
-  info: vi.fn(),
-  warn: vi.fn(),
-  error: vi.fn(),
-  createChild: vi.fn().mockReturnThis()
-});
+const createMockLogger = () => {
+  const noopAsync = async () => void 0;
+  const logger = {
+    debug: vi.fn(),
+    silly: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    trackException: vi.fn(),
+    createChild: () => logger,
+    createFileOnlyChild: () => logger,
+    setLevel: vi.fn(),
+    getLevel: () => "info",
+    getLogFilePath: () => null,
+    destroy: noopAsync
+  };
+  return logger;
+};
+function createToolContext(logger, approval) {
+  return {
+    logger,
+    services: {
+      approval,
+      search: {},
+      resources: {},
+      prompts: {},
+      mcp: {},
+      taskForker: null
+    }
+  };
+}
 describe("Directory Approval Integration Tests", () => {
   let mockLogger;
   let tempDir;
   let fileSystemService;
-  let directoryApproval;
-  let isSessionApprovedMock;
-  let addApprovedMock;
+  let approvalManager;
+  let toolContext;
+  const getFileSystemService = async (_context) => fileSystemService;
   beforeEach(async () => {
     mockLogger = createMockLogger();
     const rawTempDir = await fs.mkdtemp(path.join(os.tmpdir(), "dexto-fs-test-"));
@@ -38,12 +65,14 @@ describe("Directory Approval Integration Tests", () => {
       mockLogger
     );
     await fileSystemService.initialize();
-    isSessionApprovedMock = vi.fn().mockReturnValue(false);
-    addApprovedMock = vi.fn();
-    directoryApproval = {
-      isSessionApproved: isSessionApprovedMock,
-      addApproved: addApprovedMock
-    };
+    approvalManager = new ApprovalManager(
+      {
+        permissions: { mode: "manual" },
+        elicitation: { enabled: true }
+      },
+      mockLogger
+    );
+    toolContext = createToolContext(mockLogger, approvalManager);
     vi.clearAllMocks();
   });
   afterEach(async () => {
@@ -52,397 +81,156 @@ describe("Directory Approval Integration Tests", () => {
     } catch {
     }
   });
-  describe("Read File Tool", () => {
-    describe("getApprovalOverride", () => {
-      it("should return null for paths within working directory (no prompt needed)", async () => {
-        const tool = createReadFileTool({
-          fileSystemService,
-          directoryApproval
-        });
-        const testFile = path.join(tempDir, "test.txt");
-        await fs.writeFile(testFile, "test content");
-        const override = await tool.getApprovalOverride?.({ file_path: testFile });
-        expect(override).toBeNull();
-      });
-      it("should return directory access approval for external paths", async () => {
-        const tool = createReadFileTool({
-          fileSystemService,
-          directoryApproval
-        });
-        const externalPath = "/external/project/file.ts";
-        const override = await tool.getApprovalOverride?.({ file_path: externalPath });
-        expect(override).not.toBeNull();
-        expect(override?.type).toBe(ApprovalType.DIRECTORY_ACCESS);
-        const metadata = override?.metadata;
-        expect(metadata?.path).toBe(path.resolve(externalPath));
-        expect(metadata?.parentDir).toBe(path.dirname(path.resolve(externalPath)));
-        expect(metadata?.operation).toBe("read");
-        expect(metadata?.toolName).toBe("read_file");
-      });
-      it("should return null when external path is session-approved", async () => {
-        isSessionApprovedMock.mockReturnValue(true);
-        const tool = createReadFileTool({
-          fileSystemService,
-          directoryApproval
-        });
-        const externalPath = "/external/project/file.ts";
-        const override = await tool.getApprovalOverride?.({ file_path: externalPath });
-        expect(override).toBeNull();
-        expect(isSessionApprovedMock).toHaveBeenCalledWith(externalPath);
-      });
-      it("should return null when file_path is missing", async () => {
-        const tool = createReadFileTool({
-          fileSystemService,
-          directoryApproval
-        });
-        const override = await tool.getApprovalOverride?.({});
-        expect(override).toBeNull();
-      });
-    });
-    describe("onApprovalGranted", () => {
-      it("should add directory as session-approved when rememberDirectory is true", async () => {
-        const tool = createReadFileTool({
-          fileSystemService,
-          directoryApproval
-        });
-        const externalPath = "/external/project/file.ts";
-        await tool.getApprovalOverride?.({ file_path: externalPath });
-        tool.onApprovalGranted?.({
-          approvalId: "test-approval",
-          status: ApprovalStatus.APPROVED,
-          data: { rememberDirectory: true }
-        });
-        expect(addApprovedMock).toHaveBeenCalledWith(
-          path.dirname(path.resolve(externalPath)),
-          "session"
-        );
-      });
-      it("should add directory as once-approved when rememberDirectory is false", async () => {
-        const tool = createReadFileTool({
-          fileSystemService,
-          directoryApproval
-        });
-        const externalPath = "/external/project/file.ts";
-        await tool.getApprovalOverride?.({ file_path: externalPath });
-        tool.onApprovalGranted?.({
-          approvalId: "test-approval",
-          status: ApprovalStatus.APPROVED,
-          data: { rememberDirectory: false }
-        });
-        expect(addApprovedMock).toHaveBeenCalledWith(
-          path.dirname(path.resolve(externalPath)),
-          "once"
-        );
-      });
-      it("should default to once-approved when rememberDirectory is not specified", async () => {
-        const tool = createReadFileTool({
-          fileSystemService,
-          directoryApproval
-        });
-        const externalPath = "/external/project/file.ts";
-        await tool.getApprovalOverride?.({ file_path: externalPath });
-        tool.onApprovalGranted?.({
-          approvalId: "test-approval",
-          status: ApprovalStatus.APPROVED,
-          data: {}
-        });
-        expect(addApprovedMock).toHaveBeenCalledWith(
-          path.dirname(path.resolve(externalPath)),
-          "once"
-        );
-      });
-      it("should not call addApproved when directoryApproval is not provided", async () => {
-        const tool = createReadFileTool({
-          fileSystemService,
-          directoryApproval: void 0
-        });
-        const externalPath = "/external/project/file.ts";
-        await tool.getApprovalOverride?.({ file_path: externalPath });
-        tool.onApprovalGranted?.({
-          approvalId: "test-approval",
-          status: ApprovalStatus.APPROVED,
-          data: { rememberDirectory: true }
-        });
-        expect(addApprovedMock).not.toHaveBeenCalled();
-      });
+  describe("getApprovalOverride", () => {
+    it("should return null for paths within config-allowed roots", async () => {
+      const tool = createReadFileTool(getFileSystemService);
+      const overrideFn = tool.approval?.override;
+      expect(overrideFn).toBeDefined();
+      const testFile = path.join(tempDir, "test.txt");
+      await fs.writeFile(testFile, "test content");
+      const metadata = await overrideFn(
+        tool.inputSchema.parse({ file_path: testFile }),
+        toolContext
+      );
+      expect(metadata).toBeNull();
     });
-    describe("execute", () => {
-      it("should read file contents within working directory", async () => {
-        const tool = createReadFileTool({
-          fileSystemService,
-          directoryApproval
-        });
-        const testFile = path.join(tempDir, "readable.txt");
-        await fs.writeFile(testFile, "Hello, world!\nLine 2");
-        const result = await tool.execute({ file_path: testFile }, {});
-        expect(result.content).toBe("Hello, world!\nLine 2");
-        expect(result.lines).toBe(2);
+    it("should return directory access metadata for external paths", async () => {
+      const tool = createReadFileTool(getFileSystemService);
+      const overrideFn = tool.approval?.override;
+      expect(overrideFn).toBeDefined();
+      const externalPath = "/external/project/file.ts";
+      const metadata = await overrideFn(
+        tool.inputSchema.parse({ file_path: externalPath }),
+        toolContext
+      );
+      expect(metadata).not.toBeNull();
+      expect(metadata).toMatchObject({
+        type: "directory_access",
+        metadata: {
+          path: path.resolve(externalPath),
+          parentDir: path.dirname(path.resolve(externalPath)),
+          operation: "read",
+          toolName: "read_file"
+        }
       });
     });
-  });
-  describe("Write File Tool", () => {
-    describe("getApprovalOverride", () => {
-      it("should return null for paths within working directory", async () => {
-        const tool = createWriteFileTool({
-          fileSystemService,
-          directoryApproval
-        });
-        const testFile = path.join(tempDir, "new-file.txt");
-        const override = await tool.getApprovalOverride?.({
-          file_path: testFile,
-          content: "test"
-        });
-        expect(override).toBeNull();
-      });
-      it("should return directory access approval for external paths", async () => {
-        const tool = createWriteFileTool({
-          fileSystemService,
-          directoryApproval
-        });
-        const externalPath = "/external/project/new.ts";
-        const override = await tool.getApprovalOverride?.({
-          file_path: externalPath,
-          content: "test"
-        });
-        expect(override).not.toBeNull();
-        expect(override?.type).toBe(ApprovalType.DIRECTORY_ACCESS);
-        const metadata = override?.metadata;
-        expect(metadata?.operation).toBe("write");
-        expect(metadata?.toolName).toBe("write_file");
-      });
-      it("should return null when external path is session-approved", async () => {
-        isSessionApprovedMock.mockReturnValue(true);
-        const tool = createWriteFileTool({
-          fileSystemService,
-          directoryApproval
-        });
-        const externalPath = "/external/project/new.ts";
-        const override = await tool.getApprovalOverride?.({
-          file_path: externalPath,
-          content: "test"
-        });
-        expect(override).toBeNull();
-      });
+    it("should return null when external path is session-approved", async () => {
+      approvalManager.addApprovedDirectory("/external/project", "session");
+      const tool = createReadFileTool(getFileSystemService);
+      const overrideFn = tool.approval?.override;
+      expect(overrideFn).toBeDefined();
+      const externalPath = "/external/project/file.ts";
+      const metadata = await overrideFn(
+        tool.inputSchema.parse({ file_path: externalPath }),
+        toolContext
+      );
+      expect(metadata).toBeNull();
     });
-    describe("onApprovalGranted", () => {
-      it("should add directory as session-approved when rememberDirectory is true", async () => {
-        const tool = createWriteFileTool({
-          fileSystemService,
-          directoryApproval
-        });
-        const externalPath = "/external/project/new.ts";
-        await tool.getApprovalOverride?.({ file_path: externalPath, content: "test" });
-        tool.onApprovalGranted?.({
-          approvalId: "test-approval",
-          status: ApprovalStatus.APPROVED,
-          data: { rememberDirectory: true }
-        });
-        expect(addApprovedMock).toHaveBeenCalledWith(
-          path.dirname(path.resolve(externalPath)),
-          "session"
-        );
-      });
+    it("should still return metadata when external path is once-approved (prompt again)", async () => {
+      approvalManager.addApprovedDirectory("/external/project", "once");
+      const tool = createReadFileTool(getFileSystemService);
+      const overrideFn = tool.approval?.override;
+      expect(overrideFn).toBeDefined();
+      const externalPath = "/external/project/file.ts";
+      const metadata = await overrideFn(
+        tool.inputSchema.parse({ file_path: externalPath }),
+        toolContext
+      );
+      expect(metadata).not.toBeNull();
     });
   });
-  describe("Edit File Tool", () => {
-    describe("getApprovalOverride", () => {
-      it("should return null for paths within working directory", async () => {
-        const tool = createEditFileTool({
-          fileSystemService,
-          directoryApproval
-        });
-        const testFile = path.join(tempDir, "existing.txt");
-        const override = await tool.getApprovalOverride?.({
-          file_path: testFile,
-          old_string: "old",
-          new_string: "new"
-        });
-        expect(override).toBeNull();
-      });
-      it("should return directory access approval for external paths", async () => {
-        const tool = createEditFileTool({
-          fileSystemService,
-          directoryApproval
-        });
-        const externalPath = "/external/project/existing.ts";
-        const override = await tool.getApprovalOverride?.({
-          file_path: externalPath,
-          old_string: "old",
-          new_string: "new"
-        });
-        expect(override).not.toBeNull();
-        expect(override?.type).toBe(ApprovalType.DIRECTORY_ACCESS);
-        const metadata = override?.metadata;
-        expect(metadata?.operation).toBe("edit");
-        expect(metadata?.toolName).toBe("edit_file");
+  describe("Different tool operations", () => {
+    it("should label write operations correctly", async () => {
+      const tool = createWriteFileTool(getFileSystemService);
+      const overrideFn = tool.approval?.override;
+      expect(overrideFn).toBeDefined();
+      const externalPath = "/external/project/new.ts";
+      const metadata = await overrideFn(
+        tool.inputSchema.parse({ file_path: externalPath, content: "test" }),
+        toolContext
+      );
+      expect(metadata).not.toBeNull();
+      expect(metadata).toMatchObject({
+        type: "directory_access",
+        metadata: {
+          path: path.resolve(externalPath),
+          parentDir: path.dirname(path.resolve(externalPath)),
+          operation: "write",
+          toolName: "write_file"
+        }
       });
-      it("should return null when external path is session-approved", async () => {
-        isSessionApprovedMock.mockReturnValue(true);
-        const tool = createEditFileTool({
-          fileSystemService,
-          directoryApproval
-        });
-        const externalPath = "/external/project/existing.ts";
-        const override = await tool.getApprovalOverride?.({
+    });
+    it("should label edit operations correctly", async () => {
+      const tool = createEditFileTool(getFileSystemService);
+      const overrideFn = tool.approval?.override;
+      expect(overrideFn).toBeDefined();
+      const externalPath = "/external/project/existing.ts";
+      const metadata = await overrideFn(
+        tool.inputSchema.parse({
           file_path: externalPath,
           old_string: "old",
           new_string: "new"
-        });
-        expect(override).toBeNull();
-      });
-    });
-  });
-  describe("Session vs Once Approval Scenarios", () => {
-    it("should not prompt for subsequent requests after session approval", async () => {
-      const tool = createReadFileTool({
-        fileSystemService,
-        directoryApproval
-      });
-      const externalPath1 = "/external/project/file1.ts";
-      const externalPath2 = "/external/project/file2.ts";
-      let override = await tool.getApprovalOverride?.({ file_path: externalPath1 });
-      expect(override).not.toBeNull();
-      tool.onApprovalGranted?.({
-        approvalId: "approval-1",
-        status: ApprovalStatus.APPROVED,
-        data: { rememberDirectory: true }
-      });
-      expect(addApprovedMock).toHaveBeenCalledWith(
-        path.dirname(path.resolve(externalPath1)),
-        "session"
+        }),
+        toolContext
       );
-      isSessionApprovedMock.mockReturnValue(true);
-      override = await tool.getApprovalOverride?.({ file_path: externalPath2 });
-      expect(override).toBeNull();
-    });
-    it("should prompt for subsequent requests after once approval", async () => {
-      const tool = createReadFileTool({
-        fileSystemService,
-        directoryApproval
-      });
-      const externalPath1 = "/external/project/file1.ts";
-      const externalPath2 = "/external/project/file2.ts";
-      let override = await tool.getApprovalOverride?.({ file_path: externalPath1 });
-      expect(override).not.toBeNull();
-      tool.onApprovalGranted?.({
-        approvalId: "approval-1",
-        status: ApprovalStatus.APPROVED,
-        data: { rememberDirectory: false }
+      expect(metadata).not.toBeNull();
+      expect(metadata).toMatchObject({
+        type: "directory_access",
+        metadata: {
+          path: path.resolve(externalPath),
+          parentDir: path.dirname(path.resolve(externalPath)),
+          operation: "edit",
+          toolName: "edit_file"
+        }
       });
-      expect(addApprovedMock).toHaveBeenCalledWith(
-        path.dirname(path.resolve(externalPath1)),
-        "once"
-      );
-      isSessionApprovedMock.mockReturnValue(false);
-      override = await tool.getApprovalOverride?.({ file_path: externalPath2 });
-      expect(override).not.toBeNull();
     });
   });
-  describe("Path Containment Scenarios", () => {
+  describe("Path containment scenarios", () => {
     it("should cover child paths when parent directory is session-approved", async () => {
-      const tool = createReadFileTool({
-        fileSystemService,
-        directoryApproval
-      });
-      isSessionApprovedMock.mockImplementation((filePath) => {
-        const normalizedPath = path.resolve(filePath);
-        const approvedDir = "/external/project";
-        return normalizedPath.startsWith(approvedDir + path.sep) || normalizedPath === approvedDir;
-      });
-      let override = await tool.getApprovalOverride?.({
-        file_path: "/external/project/file.ts"
-      });
-      expect(override).toBeNull();
-      override = await tool.getApprovalOverride?.({
-        file_path: "/external/project/deep/nested/file.ts"
-      });
-      expect(override).toBeNull();
+      const tool = createReadFileTool(getFileSystemService);
+      const overrideFn = tool.approval?.override;
+      expect(overrideFn).toBeDefined();
+      approvalManager.addApprovedDirectory("/external/project", "session");
+      const metadata1 = await overrideFn(
+        tool.inputSchema.parse({ file_path: "/external/project/file.ts" }),
+        toolContext
+      );
+      expect(metadata1).toBeNull();
+      const metadata2 = await overrideFn(
+        tool.inputSchema.parse({ file_path: "/external/project/deep/nested/file.ts" }),
+        toolContext
+      );
+      expect(metadata2).toBeNull();
     });
     it("should NOT cover sibling directories", async () => {
-      const tool = createReadFileTool({
-        fileSystemService,
-        directoryApproval
-      });
-      isSessionApprovedMock.mockImplementation((filePath) => {
-        const normalizedPath = path.resolve(filePath);
-        const approvedDir = "/external/sub";
-        return normalizedPath.startsWith(approvedDir + path.sep) || normalizedPath === approvedDir;
-      });
-      let override = await tool.getApprovalOverride?.({ file_path: "/external/sub/file.ts" });
-      expect(override).toBeNull();
-      override = await tool.getApprovalOverride?.({ file_path: "/external/other/file.ts" });
-      expect(override).not.toBeNull();
-    });
-  });
-  describe("Different External Directories Scenarios", () => {
-    it("should require separate approval for different external directories", async () => {
-      const tool = createReadFileTool({
-        fileSystemService,
-        directoryApproval
-      });
-      const dir1Path = "/external/project1/file.ts";
-      const dir2Path = "/external/project2/file.ts";
-      const override1 = await tool.getApprovalOverride?.({ file_path: dir1Path });
-      expect(override1).not.toBeNull();
-      const metadata1 = override1?.metadata;
-      expect(metadata1?.parentDir).toBe("/external/project1");
-      const override2 = await tool.getApprovalOverride?.({ file_path: dir2Path });
-      expect(override2).not.toBeNull();
-      const metadata2 = override2?.metadata;
-      expect(metadata2?.parentDir).toBe("/external/project2");
-    });
-  });
-  describe("Mixed Operations Scenarios", () => {
-    it("should share directory approval across different file operations", async () => {
-      const readTool = createReadFileTool({ fileSystemService, directoryApproval });
-      const writeTool = createWriteFileTool({ fileSystemService, directoryApproval });
-      const editTool = createEditFileTool({ fileSystemService, directoryApproval });
-      const externalDir = "/external/project";
-      expect(
-        await readTool.getApprovalOverride?.({ file_path: `${externalDir}/file1.ts` })
-      ).not.toBeNull();
-      expect(
-        await writeTool.getApprovalOverride?.({
-          file_path: `${externalDir}/file2.ts`,
-          content: "test"
-        })
-      ).not.toBeNull();
-      expect(
-        await editTool.getApprovalOverride?.({
-          file_path: `${externalDir}/file3.ts`,
-          old_string: "a",
-          new_string: "b"
-        })
-      ).not.toBeNull();
-      isSessionApprovedMock.mockReturnValue(true);
-      expect(
-        await readTool.getApprovalOverride?.({ file_path: `${externalDir}/file1.ts` })
-      ).toBeNull();
-      expect(
-        await writeTool.getApprovalOverride?.({
-          file_path: `${externalDir}/file2.ts`,
-          content: "test"
-        })
-      ).toBeNull();
-      expect(
-        await editTool.getApprovalOverride?.({
-          file_path: `${externalDir}/file3.ts`,
-          old_string: "a",
-          new_string: "b"
-        })
-      ).toBeNull();
+      const tool = createReadFileTool(getFileSystemService);
+      const overrideFn = tool.approval?.override;
+      expect(overrideFn).toBeDefined();
+      approvalManager.addApprovedDirectory("/external/sub", "session");
+      const metadata1 = await overrideFn(
+        tool.inputSchema.parse({ file_path: "/external/sub/file.ts" }),
+        toolContext
+      );
+      expect(metadata1).toBeNull();
+      const metadata2 = await overrideFn(
+        tool.inputSchema.parse({ file_path: "/external/other/file.ts" }),
+        toolContext
+      );
+      expect(metadata2).not.toBeNull();
     });
   });
-  describe("Without Directory Approval Callbacks", () => {
-    it("should work without directory approval callbacks (all paths need normal tool confirmation)", async () => {
-      const tool = createReadFileTool({
-        fileSystemService,
-        directoryApproval: void 0
-      });
-      const override = await tool.getApprovalOverride?.({
-        file_path: "/external/project/file.ts"
-      });
-      expect(override).not.toBeNull();
+  describe("Without ApprovalManager in context", () => {
+    it("should throw for external paths", async () => {
+      const tool = createReadFileTool(getFileSystemService);
+      const overrideFn = tool.approval?.override;
+      expect(overrideFn).toBeDefined();
+      const contextWithoutApprovalManager = { logger: mockLogger };
+      await expect(
+        overrideFn(
+          tool.inputSchema.parse({ file_path: "/external/project/file.ts" }),
+          contextWithoutApprovalManager
+        )
+      ).rejects.toBeInstanceOf(DextoRuntimeError);
     });
   });
 });