@dexto/tools-filesystem 1.5.8 → 1.6.0

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

@@ -30,20 +30,43 @@ var import_write_file_tool = require("./write-file-tool.js");
 var import_edit_file_tool = require("./edit-file-tool.js");
 var import_filesystem_service = require("./filesystem-service.js");
 var import_core = 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 noopAsync = async () => void 0;
+  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: () => logger,
+    setLevel: import_vitest.vi.fn(),
+    getLevel: () => "info",
+    getLogFilePath: () => null,
+    destroy: noopAsync
+  };
+  return logger;
+};
+function createToolContext(logger, approval) {
+  return {
+    logger,
+    services: {
+      approval,
+      search: {},
+      resources: {},
+      prompts: {},
+      mcp: {},
+      taskForker: null
+    }
+  };
+}
 (0, import_vitest.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;
   (0, import_vitest.beforeEach)(async () => {
     mockLogger = createMockLogger();
     const rawTempDir = await fs.mkdtemp(path.join(os.tmpdir(), "dexto-fs-test-"));
@@ -61,12 +84,14 @@ const createMockLogger = () => ({
       mockLogger
     );
     await fileSystemService.initialize();
-    isSessionApprovedMock = import_vitest.vi.fn().mockReturnValue(false);
-    addApprovedMock = import_vitest.vi.fn();
-    directoryApproval = {
-      isSessionApproved: isSessionApprovedMock,
-      addApproved: addApprovedMock
-    };
+    approvalManager = new import_core.ApprovalManager(
+      {
+        permissions: { mode: "manual" },
+        elicitation: { enabled: true }
+      },
+      mockLogger
+    );
+    toolContext = createToolContext(mockLogger, approvalManager);
     import_vitest.vi.clearAllMocks();
   });
   (0, import_vitest.afterEach)(async () => {
@@ -78,22 +103,22 @@ const createMockLogger = () => ({
   (0, import_vitest.describe)("Read File Tool", () => {
     (0, import_vitest.describe)("getApprovalOverride", () => {
       (0, import_vitest.it)("should return null for paths within working directory (no prompt needed)", async () => {
-        const tool = (0, import_read_file_tool.createReadFileTool)({
-          fileSystemService,
-          directoryApproval
-        });
+        const tool = (0, import_read_file_tool.createReadFileTool)(getFileSystemService);
         const testFile = path.join(tempDir, "test.txt");
         await fs.writeFile(testFile, "test content");
-        const override = await tool.getApprovalOverride?.({ file_path: testFile });
+        const override = await tool.getApprovalOverride?.(
+          tool.inputSchema.parse({ file_path: testFile }),
+          toolContext
+        );
         (0, import_vitest.expect)(override).toBeNull();
       });
       (0, import_vitest.it)("should return directory access approval for external paths", async () => {
-        const tool = (0, import_read_file_tool.createReadFileTool)({
-          fileSystemService,
-          directoryApproval
-        });
+        const tool = (0, import_read_file_tool.createReadFileTool)(getFileSystemService);
         const externalPath = "/external/project/file.ts";
-        const override = await tool.getApprovalOverride?.({ file_path: externalPath });
+        const override = await tool.getApprovalOverride?.(
+          tool.inputSchema.parse({ file_path: externalPath }),
+          toolContext
+        );
         (0, import_vitest.expect)(override).not.toBeNull();
         (0, import_vitest.expect)(override?.type).toBe(import_core.ApprovalType.DIRECTORY_ACCESS);
         const metadata = override?.metadata;
@@ -103,101 +128,96 @@ const createMockLogger = () => ({
         (0, import_vitest.expect)(metadata?.toolName).toBe("read_file");
       });
       (0, import_vitest.it)("should return null when external path is session-approved", async () => {
-        isSessionApprovedMock.mockReturnValue(true);
-        const tool = (0, import_read_file_tool.createReadFileTool)({
-          fileSystemService,
-          directoryApproval
-        });
+        approvalManager.addApprovedDirectory("/external/project", "session");
+        const tool = (0, import_read_file_tool.createReadFileTool)(getFileSystemService);
         const externalPath = "/external/project/file.ts";
-        const override = await tool.getApprovalOverride?.({ file_path: externalPath });
-        (0, import_vitest.expect)(override).toBeNull();
-        (0, import_vitest.expect)(isSessionApprovedMock).toHaveBeenCalledWith(externalPath);
-      });
-      (0, import_vitest.it)("should return null when file_path is missing", async () => {
-        const tool = (0, import_read_file_tool.createReadFileTool)({
-          fileSystemService,
-          directoryApproval
-        });
-        const override = await tool.getApprovalOverride?.({});
+        const override = await tool.getApprovalOverride?.(
+          tool.inputSchema.parse({ file_path: externalPath }),
+          toolContext
+        );
         (0, import_vitest.expect)(override).toBeNull();
       });
     });
     (0, import_vitest.describe)("onApprovalGranted", () => {
       (0, import_vitest.it)("should add directory as session-approved when rememberDirectory is true", async () => {
-        const tool = (0, import_read_file_tool.createReadFileTool)({
-          fileSystemService,
-          directoryApproval
-        });
+        const tool = (0, import_read_file_tool.createReadFileTool)(getFileSystemService);
         const externalPath = "/external/project/file.ts";
-        await tool.getApprovalOverride?.({ file_path: externalPath });
-        tool.onApprovalGranted?.({
-          approvalId: "test-approval",
-          status: import_core.ApprovalStatus.APPROVED,
-          data: { rememberDirectory: true }
-        });
-        (0, import_vitest.expect)(addApprovedMock).toHaveBeenCalledWith(
-          path.dirname(path.resolve(externalPath)),
-          "session"
+        const approvalRequest = await tool.getApprovalOverride?.(
+          tool.inputSchema.parse({ file_path: externalPath }),
+          toolContext
         );
+        (0, import_vitest.expect)(approvalRequest).not.toBeNull();
+        if (!approvalRequest) {
+          throw new Error("Expected approval request");
+        }
+        tool.onApprovalGranted?.(
+          {
+            approvalId: "test-approval",
+            status: import_core.ApprovalStatus.APPROVED,
+            data: { rememberDirectory: true }
+          },
+          toolContext,
+          approvalRequest
+        );
+        (0, import_vitest.expect)(
+          approvalManager.getApprovedDirectories().get(path.dirname(path.resolve(externalPath)))
+        ).toBe("session");
       });
       (0, import_vitest.it)("should add directory as once-approved when rememberDirectory is false", async () => {
-        const tool = (0, import_read_file_tool.createReadFileTool)({
-          fileSystemService,
-          directoryApproval
-        });
+        const tool = (0, import_read_file_tool.createReadFileTool)(getFileSystemService);
         const externalPath = "/external/project/file.ts";
-        await tool.getApprovalOverride?.({ file_path: externalPath });
-        tool.onApprovalGranted?.({
-          approvalId: "test-approval",
-          status: import_core.ApprovalStatus.APPROVED,
-          data: { rememberDirectory: false }
-        });
-        (0, import_vitest.expect)(addApprovedMock).toHaveBeenCalledWith(
-          path.dirname(path.resolve(externalPath)),
-          "once"
+        const approvalRequest = await tool.getApprovalOverride?.(
+          tool.inputSchema.parse({ file_path: externalPath }),
+          toolContext
+        );
+        (0, import_vitest.expect)(approvalRequest).not.toBeNull();
+        if (!approvalRequest) {
+          throw new Error("Expected approval request");
+        }
+        tool.onApprovalGranted?.(
+          {
+            approvalId: "test-approval",
+            status: import_core.ApprovalStatus.APPROVED,
+            data: { rememberDirectory: false }
+          },
+          toolContext,
+          approvalRequest
         );
+        (0, import_vitest.expect)(
+          approvalManager.getApprovedDirectories().get(path.dirname(path.resolve(externalPath)))
+        ).toBe("once");
       });
       (0, import_vitest.it)("should default to once-approved when rememberDirectory is not specified", async () => {
-        const tool = (0, import_read_file_tool.createReadFileTool)({
-          fileSystemService,
-          directoryApproval
-        });
+        const tool = (0, import_read_file_tool.createReadFileTool)(getFileSystemService);
         const externalPath = "/external/project/file.ts";
-        await tool.getApprovalOverride?.({ file_path: externalPath });
-        tool.onApprovalGranted?.({
-          approvalId: "test-approval",
-          status: import_core.ApprovalStatus.APPROVED,
-          data: {}
-        });
-        (0, import_vitest.expect)(addApprovedMock).toHaveBeenCalledWith(
-          path.dirname(path.resolve(externalPath)),
-          "once"
+        const approvalRequest = await tool.getApprovalOverride?.(
+          tool.inputSchema.parse({ file_path: externalPath }),
+          toolContext
         );
-      });
-      (0, import_vitest.it)("should not call addApproved when directoryApproval is not provided", async () => {
-        const tool = (0, import_read_file_tool.createReadFileTool)({
-          fileSystemService,
-          directoryApproval: void 0
-        });
-        const externalPath = "/external/project/file.ts";
-        await tool.getApprovalOverride?.({ file_path: externalPath });
-        tool.onApprovalGranted?.({
-          approvalId: "test-approval",
-          status: import_core.ApprovalStatus.APPROVED,
-          data: { rememberDirectory: true }
-        });
-        (0, import_vitest.expect)(addApprovedMock).not.toHaveBeenCalled();
+        (0, import_vitest.expect)(approvalRequest).not.toBeNull();
+        if (!approvalRequest) {
+          throw new Error("Expected approval request");
+        }
+        tool.onApprovalGranted?.(
+          {
+            approvalId: "test-approval",
+            status: import_core.ApprovalStatus.APPROVED,
+            data: {}
+          },
+          toolContext,
+          approvalRequest
+        );
+        (0, import_vitest.expect)(
+          approvalManager.getApprovedDirectories().get(path.dirname(path.resolve(externalPath)))
+        ).toBe("once");
       });
     });
     (0, import_vitest.describe)("execute", () => {
       (0, import_vitest.it)("should read file contents within working directory", async () => {
-        const tool = (0, import_read_file_tool.createReadFileTool)({
-          fileSystemService,
-          directoryApproval
-        });
+        const tool = (0, import_read_file_tool.createReadFileTool)(getFileSystemService);
         const testFile = path.join(tempDir, "readable.txt");
         await fs.writeFile(testFile, "Hello, world!\nLine 2");
-        const result = await tool.execute({ file_path: testFile }, {});
+        const result = await tool.execute({ file_path: testFile }, toolContext);
         (0, import_vitest.expect)(result.content).toBe("Hello, world!\nLine 2");
         (0, import_vitest.expect)(result.lines).toBe(2);
       });
@@ -206,27 +226,21 @@ const createMockLogger = () => ({
   (0, import_vitest.describe)("Write File Tool", () => {
     (0, import_vitest.describe)("getApprovalOverride", () => {
       (0, import_vitest.it)("should return null for paths within working directory", async () => {
-        const tool = (0, import_write_file_tool.createWriteFileTool)({
-          fileSystemService,
-          directoryApproval
-        });
+        const tool = (0, import_write_file_tool.createWriteFileTool)(getFileSystemService);
         const testFile = path.join(tempDir, "new-file.txt");
-        const override = await tool.getApprovalOverride?.({
-          file_path: testFile,
-          content: "test"
-        });
+        const override = await tool.getApprovalOverride?.(
+          tool.inputSchema.parse({ file_path: testFile, content: "test" }),
+          toolContext
+        );
         (0, import_vitest.expect)(override).toBeNull();
       });
       (0, import_vitest.it)("should return directory access approval for external paths", async () => {
-        const tool = (0, import_write_file_tool.createWriteFileTool)({
-          fileSystemService,
-          directoryApproval
-        });
+        const tool = (0, import_write_file_tool.createWriteFileTool)(getFileSystemService);
         const externalPath = "/external/project/new.ts";
-        const override = await tool.getApprovalOverride?.({
-          file_path: externalPath,
-          content: "test"
-        });
+        const override = await tool.getApprovalOverride?.(
+          tool.inputSchema.parse({ file_path: externalPath, content: "test" }),
+          toolContext
+        );
         (0, import_vitest.expect)(override).not.toBeNull();
         (0, import_vitest.expect)(override?.type).toBe(import_core.ApprovalType.DIRECTORY_ACCESS);
         const metadata = override?.metadata;
@@ -234,65 +248,69 @@ const createMockLogger = () => ({
         (0, import_vitest.expect)(metadata?.toolName).toBe("write_file");
       });
       (0, import_vitest.it)("should return null when external path is session-approved", async () => {
-        isSessionApprovedMock.mockReturnValue(true);
-        const tool = (0, import_write_file_tool.createWriteFileTool)({
-          fileSystemService,
-          directoryApproval
-        });
+        approvalManager.addApprovedDirectory("/external/project", "session");
+        const tool = (0, import_write_file_tool.createWriteFileTool)(getFileSystemService);
         const externalPath = "/external/project/new.ts";
-        const override = await tool.getApprovalOverride?.({
-          file_path: externalPath,
-          content: "test"
-        });
+        const override = await tool.getApprovalOverride?.(
+          tool.inputSchema.parse({ file_path: externalPath, content: "test" }),
+          toolContext
+        );
         (0, import_vitest.expect)(override).toBeNull();
       });
     });
     (0, import_vitest.describe)("onApprovalGranted", () => {
       (0, import_vitest.it)("should add directory as session-approved when rememberDirectory is true", async () => {
-        const tool = (0, import_write_file_tool.createWriteFileTool)({
-          fileSystemService,
-          directoryApproval
-        });
+        const tool = (0, import_write_file_tool.createWriteFileTool)(getFileSystemService);
         const externalPath = "/external/project/new.ts";
-        await tool.getApprovalOverride?.({ file_path: externalPath, content: "test" });
-        tool.onApprovalGranted?.({
-          approvalId: "test-approval",
-          status: import_core.ApprovalStatus.APPROVED,
-          data: { rememberDirectory: true }
-        });
-        (0, import_vitest.expect)(addApprovedMock).toHaveBeenCalledWith(
-          path.dirname(path.resolve(externalPath)),
-          "session"
+        const approvalRequest = await tool.getApprovalOverride?.(
+          tool.inputSchema.parse({ file_path: externalPath, content: "test" }),
+          toolContext
+        );
+        (0, import_vitest.expect)(approvalRequest).not.toBeNull();
+        if (!approvalRequest) {
+          throw new Error("Expected approval request");
+        }
+        tool.onApprovalGranted?.(
+          {
+            approvalId: "test-approval",
+            status: import_core.ApprovalStatus.APPROVED,
+            data: { rememberDirectory: true }
+          },
+          toolContext,
+          approvalRequest
         );
+        (0, import_vitest.expect)(
+          approvalManager.getApprovedDirectories().get(path.dirname(path.resolve(externalPath)))
+        ).toBe("session");
       });
     });
   });
   (0, import_vitest.describe)("Edit File Tool", () => {
     (0, import_vitest.describe)("getApprovalOverride", () => {
       (0, import_vitest.it)("should return null for paths within working directory", async () => {
-        const tool = (0, import_edit_file_tool.createEditFileTool)({
-          fileSystemService,
-          directoryApproval
-        });
+        const tool = (0, import_edit_file_tool.createEditFileTool)(getFileSystemService);
         const testFile = path.join(tempDir, "existing.txt");
-        const override = await tool.getApprovalOverride?.({
-          file_path: testFile,
-          old_string: "old",
-          new_string: "new"
-        });
+        const override = await tool.getApprovalOverride?.(
+          tool.inputSchema.parse({
+            file_path: testFile,
+            old_string: "old",
+            new_string: "new"
+          }),
+          toolContext
+        );
         (0, import_vitest.expect)(override).toBeNull();
       });
       (0, import_vitest.it)("should return directory access approval for external paths", async () => {
-        const tool = (0, import_edit_file_tool.createEditFileTool)({
-          fileSystemService,
-          directoryApproval
-        });
+        const tool = (0, import_edit_file_tool.createEditFileTool)(getFileSystemService);
         const externalPath = "/external/project/existing.ts";
-        const override = await tool.getApprovalOverride?.({
-          file_path: externalPath,
-          old_string: "old",
-          new_string: "new"
-        });
+        const override = await tool.getApprovalOverride?.(
+          tool.inputSchema.parse({
+            file_path: externalPath,
+            old_string: "old",
+            new_string: "new"
+          }),
+          toolContext
+        );
         (0, import_vitest.expect)(override).not.toBeNull();
         (0, import_vitest.expect)(override?.type).toBe(import_core.ApprovalType.DIRECTORY_ACCESS);
         const metadata = override?.metadata;
@@ -300,116 +318,129 @@ const createMockLogger = () => ({
         (0, import_vitest.expect)(metadata?.toolName).toBe("edit_file");
       });
       (0, import_vitest.it)("should return null when external path is session-approved", async () => {
-        isSessionApprovedMock.mockReturnValue(true);
-        const tool = (0, import_edit_file_tool.createEditFileTool)({
-          fileSystemService,
-          directoryApproval
-        });
+        approvalManager.addApprovedDirectory("/external/project", "session");
+        const tool = (0, import_edit_file_tool.createEditFileTool)(getFileSystemService);
         const externalPath = "/external/project/existing.ts";
-        const override = await tool.getApprovalOverride?.({
-          file_path: externalPath,
-          old_string: "old",
-          new_string: "new"
-        });
+        const override = await tool.getApprovalOverride?.(
+          tool.inputSchema.parse({
+            file_path: externalPath,
+            old_string: "old",
+            new_string: "new"
+          }),
+          toolContext
+        );
         (0, import_vitest.expect)(override).toBeNull();
       });
     });
   });
   (0, import_vitest.describe)("Session vs Once Approval Scenarios", () => {
     (0, import_vitest.it)("should not prompt for subsequent requests after session approval", async () => {
-      const tool = (0, import_read_file_tool.createReadFileTool)({
-        fileSystemService,
-        directoryApproval
-      });
+      const tool = (0, import_read_file_tool.createReadFileTool)(getFileSystemService);
       const externalPath1 = "/external/project/file1.ts";
       const externalPath2 = "/external/project/file2.ts";
-      let override = await tool.getApprovalOverride?.({ file_path: externalPath1 });
+      let override = await tool.getApprovalOverride?.(
+        tool.inputSchema.parse({ file_path: externalPath1 }),
+        toolContext
+      );
       (0, import_vitest.expect)(override).not.toBeNull();
-      tool.onApprovalGranted?.({
-        approvalId: "approval-1",
-        status: import_core.ApprovalStatus.APPROVED,
-        data: { rememberDirectory: true }
-      });
-      (0, import_vitest.expect)(addApprovedMock).toHaveBeenCalledWith(
-        path.dirname(path.resolve(externalPath1)),
-        "session"
+      if (!override) {
+        throw new Error("Expected approval request");
+      }
+      tool.onApprovalGranted?.(
+        {
+          approvalId: "approval-1",
+          status: import_core.ApprovalStatus.APPROVED,
+          data: { rememberDirectory: true }
+        },
+        toolContext,
+        override
+      );
+      (0, import_vitest.expect)(
+        approvalManager.getApprovedDirectories().get(path.dirname(path.resolve(externalPath1)))
+      ).toBe("session");
+      override = await tool.getApprovalOverride?.(
+        tool.inputSchema.parse({ file_path: externalPath2 }),
+        toolContext
       );
-      isSessionApprovedMock.mockReturnValue(true);
-      override = await tool.getApprovalOverride?.({ file_path: externalPath2 });
       (0, import_vitest.expect)(override).toBeNull();
     });
     (0, import_vitest.it)("should prompt for subsequent requests after once approval", async () => {
-      const tool = (0, import_read_file_tool.createReadFileTool)({
-        fileSystemService,
-        directoryApproval
-      });
+      const tool = (0, import_read_file_tool.createReadFileTool)(getFileSystemService);
       const externalPath1 = "/external/project/file1.ts";
       const externalPath2 = "/external/project/file2.ts";
-      let override = await tool.getApprovalOverride?.({ file_path: externalPath1 });
+      let override = await tool.getApprovalOverride?.(
+        tool.inputSchema.parse({ file_path: externalPath1 }),
+        toolContext
+      );
       (0, import_vitest.expect)(override).not.toBeNull();
-      tool.onApprovalGranted?.({
-        approvalId: "approval-1",
-        status: import_core.ApprovalStatus.APPROVED,
-        data: { rememberDirectory: false }
-      });
-      (0, import_vitest.expect)(addApprovedMock).toHaveBeenCalledWith(
-        path.dirname(path.resolve(externalPath1)),
-        "once"
+      if (!override) {
+        throw new Error("Expected approval request");
+      }
+      tool.onApprovalGranted?.(
+        {
+          approvalId: "approval-1",
+          status: import_core.ApprovalStatus.APPROVED,
+          data: { rememberDirectory: false }
+        },
+        toolContext,
+        override
+      );
+      (0, import_vitest.expect)(
+        approvalManager.getApprovedDirectories().get(path.dirname(path.resolve(externalPath1)))
+      ).toBe("once");
+      override = await tool.getApprovalOverride?.(
+        tool.inputSchema.parse({ file_path: externalPath2 }),
+        toolContext
       );
-      isSessionApprovedMock.mockReturnValue(false);
-      override = await tool.getApprovalOverride?.({ file_path: externalPath2 });
       (0, import_vitest.expect)(override).not.toBeNull();
     });
   });
   (0, import_vitest.describe)("Path Containment Scenarios", () => {
     (0, import_vitest.it)("should cover child paths when parent directory is session-approved", async () => {
-      const tool = (0, import_read_file_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"
-      });
+      const tool = (0, import_read_file_tool.createReadFileTool)(getFileSystemService);
+      approvalManager.addApprovedDirectory("/external/project", "session");
+      let override = await tool.getApprovalOverride?.(
+        tool.inputSchema.parse({ file_path: "/external/project/file.ts" }),
+        toolContext
+      );
       (0, import_vitest.expect)(override).toBeNull();
-      override = await tool.getApprovalOverride?.({
-        file_path: "/external/project/deep/nested/file.ts"
-      });
+      override = await tool.getApprovalOverride?.(
+        tool.inputSchema.parse({ file_path: "/external/project/deep/nested/file.ts" }),
+        toolContext
+      );
       (0, import_vitest.expect)(override).toBeNull();
     });
     (0, import_vitest.it)("should NOT cover sibling directories", async () => {
-      const tool = (0, import_read_file_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" });
+      const tool = (0, import_read_file_tool.createReadFileTool)(getFileSystemService);
+      approvalManager.addApprovedDirectory("/external/sub", "session");
+      let override = await tool.getApprovalOverride?.(
+        tool.inputSchema.parse({ file_path: "/external/sub/file.ts" }),
+        toolContext
+      );
       (0, import_vitest.expect)(override).toBeNull();
-      override = await tool.getApprovalOverride?.({ file_path: "/external/other/file.ts" });
+      override = await tool.getApprovalOverride?.(
+        tool.inputSchema.parse({ file_path: "/external/other/file.ts" }),
+        toolContext
+      );
       (0, import_vitest.expect)(override).not.toBeNull();
     });
   });
   (0, import_vitest.describe)("Different External Directories Scenarios", () => {
     (0, import_vitest.it)("should require separate approval for different external directories", async () => {
-      const tool = (0, import_read_file_tool.createReadFileTool)({
-        fileSystemService,
-        directoryApproval
-      });
+      const tool = (0, import_read_file_tool.createReadFileTool)(getFileSystemService);
       const dir1Path = "/external/project1/file.ts";
       const dir2Path = "/external/project2/file.ts";
-      const override1 = await tool.getApprovalOverride?.({ file_path: dir1Path });
+      const override1 = await tool.getApprovalOverride?.(
+        tool.inputSchema.parse({ file_path: dir1Path }),
+        toolContext
+      );
       (0, import_vitest.expect)(override1).not.toBeNull();
       const metadata1 = override1?.metadata;
       (0, import_vitest.expect)(metadata1?.parentDir).toBe("/external/project1");
-      const override2 = await tool.getApprovalOverride?.({ file_path: dir2Path });
+      const override2 = await tool.getApprovalOverride?.(
+        tool.inputSchema.parse({ file_path: dir2Path }),
+        toolContext
+      );
       (0, import_vitest.expect)(override2).not.toBeNull();
       const metadata2 = override2?.metadata;
       (0, import_vitest.expect)(metadata2?.parentDir).toBe("/external/project2");
@@ -417,55 +448,58 @@ const createMockLogger = () => ({
   });
   (0, import_vitest.describe)("Mixed Operations Scenarios", () => {
     (0, import_vitest.it)("should share directory approval across different file operations", async () => {
-      const readTool = (0, import_read_file_tool.createReadFileTool)({ fileSystemService, directoryApproval });
-      const writeTool = (0, import_write_file_tool.createWriteFileTool)({ fileSystemService, directoryApproval });
-      const editTool = (0, import_edit_file_tool.createEditFileTool)({ fileSystemService, directoryApproval });
+      const readTool = (0, import_read_file_tool.createReadFileTool)(getFileSystemService);
+      const writeTool = (0, import_write_file_tool.createWriteFileTool)(getFileSystemService);
+      const editTool = (0, import_edit_file_tool.createEditFileTool)(getFileSystemService);
       const externalDir = "/external/project";
+      const approvalRequest = await readTool.getApprovalOverride?.(
+        readTool.inputSchema.parse({ file_path: `${externalDir}/file1.ts` }),
+        toolContext
+      );
+      (0, import_vitest.expect)(approvalRequest).not.toBeNull();
+      if (!approvalRequest) {
+        throw new Error("Expected approval request");
+      }
+      readTool.onApprovalGranted?.(
+        {
+          approvalId: "approval-1",
+          status: import_core.ApprovalStatus.APPROVED,
+          data: { rememberDirectory: true }
+        },
+        toolContext,
+        approvalRequest
+      );
       (0, import_vitest.expect)(
-        await readTool.getApprovalOverride?.({ file_path: `${externalDir}/file1.ts` })
-      ).not.toBeNull();
-      (0, import_vitest.expect)(
-        await writeTool.getApprovalOverride?.({
-          file_path: `${externalDir}/file2.ts`,
-          content: "test"
-        })
-      ).not.toBeNull();
-      (0, import_vitest.expect)(
-        await editTool.getApprovalOverride?.({
-          file_path: `${externalDir}/file3.ts`,
-          old_string: "a",
-          new_string: "b"
-        })
-      ).not.toBeNull();
-      isSessionApprovedMock.mockReturnValue(true);
-      (0, import_vitest.expect)(
-        await readTool.getApprovalOverride?.({ file_path: `${externalDir}/file1.ts` })
-      ).toBeNull();
-      (0, import_vitest.expect)(
-        await writeTool.getApprovalOverride?.({
-          file_path: `${externalDir}/file2.ts`,
-          content: "test"
-        })
+        await writeTool.getApprovalOverride?.(
+          writeTool.inputSchema.parse({
+            file_path: `${externalDir}/file2.ts`,
+            content: "test"
+          }),
+          toolContext
+        )
       ).toBeNull();
       (0, import_vitest.expect)(
-        await editTool.getApprovalOverride?.({
-          file_path: `${externalDir}/file3.ts`,
-          old_string: "a",
-          new_string: "b"
-        })
+        await editTool.getApprovalOverride?.(
+          editTool.inputSchema.parse({
+            file_path: `${externalDir}/file3.ts`,
+            old_string: "a",
+            new_string: "b"
+          }),
+          toolContext
+        )
       ).toBeNull();
     });
   });
-  (0, import_vitest.describe)("Without Directory Approval Callbacks", () => {
-    (0, import_vitest.it)("should work without directory approval callbacks (all paths need normal tool confirmation)", async () => {
-      const tool = (0, import_read_file_tool.createReadFileTool)({
-        fileSystemService,
-        directoryApproval: void 0
-      });
-      const override = await tool.getApprovalOverride?.({
-        file_path: "/external/project/file.ts"
-      });
-      (0, import_vitest.expect)(override).not.toBeNull();
+  (0, import_vitest.describe)("Without ApprovalManager in context", () => {
+    (0, import_vitest.it)("should throw for external paths", async () => {
+      const tool = (0, import_read_file_tool.createReadFileTool)(getFileSystemService);
+      const contextWithoutApprovalManager = { logger: mockLogger };
+      await (0, import_vitest.expect)(
+        tool.getApprovalOverride?.(
+          tool.inputSchema.parse({ file_path: "/external/project/file.ts" }),
+          contextWithoutApprovalManager
+        )
+      ).rejects.toBeInstanceOf(import_core.DextoRuntimeError);
     });
   });
 });