@dexto/tools-filesystem 1.5.8 → 1.6.1

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

@@ -25,25 +25,49 @@ 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_core = require("@dexto/core");
+var import_filesystem_service = require("./filesystem-service.js");
 var import_read_file_tool = require("./read-file-tool.js");
 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,
+    createFileOnlyChild: () => 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 +85,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 () => {
@@ -75,397 +101,156 @@ const createMockLogger = () => ({
     } catch {
     }
   });
-  (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 testFile = path.join(tempDir, "test.txt");
-        await fs.writeFile(testFile, "test content");
-        const override = await tool.getApprovalOverride?.({ file_path: testFile });
-        (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 externalPath = "/external/project/file.ts";
-        const override = await tool.getApprovalOverride?.({ file_path: externalPath });
-        (0, import_vitest.expect)(override).not.toBeNull();
-        (0, import_vitest.expect)(override?.type).toBe(import_core.ApprovalType.DIRECTORY_ACCESS);
-        const metadata = override?.metadata;
-        (0, import_vitest.expect)(metadata?.path).toBe(path.resolve(externalPath));
-        (0, import_vitest.expect)(metadata?.parentDir).toBe(path.dirname(path.resolve(externalPath)));
-        (0, import_vitest.expect)(metadata?.operation).toBe("read");
-        (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
-        });
-        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?.({});
-        (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 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"
-        );
-      });
-      (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 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"
-        );
-      });
-      (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 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"
-        );
-      });
-      (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.describe)("getApprovalOverride", () => {
+    (0, import_vitest.it)("should return null for paths within config-allowed roots", async () => {
+      const tool = (0, import_read_file_tool.createReadFileTool)(getFileSystemService);
+      const overrideFn = tool.approval?.override;
+      (0, import_vitest.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
+      );
+      (0, import_vitest.expect)(metadata).toBeNull();
     });
-    (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 testFile = path.join(tempDir, "readable.txt");
-        await fs.writeFile(testFile, "Hello, world!\nLine 2");
-        const result = await tool.execute({ file_path: testFile }, {});
-        (0, import_vitest.expect)(result.content).toBe("Hello, world!\nLine 2");
-        (0, import_vitest.expect)(result.lines).toBe(2);
+    (0, import_vitest.it)("should return directory access metadata for external paths", async () => {
+      const tool = (0, import_read_file_tool.createReadFileTool)(getFileSystemService);
+      const overrideFn = tool.approval?.override;
+      (0, import_vitest.expect)(overrideFn).toBeDefined();
+      const externalPath = "/external/project/file.ts";
+      const metadata = await overrideFn(
+        tool.inputSchema.parse({ file_path: externalPath }),
+        toolContext
+      );
+      (0, import_vitest.expect)(metadata).not.toBeNull();
+      (0, import_vitest.expect)(metadata).toMatchObject({
+        type: "directory_access",
+        metadata: {
+          path: path.resolve(externalPath),
+          parentDir: path.dirname(path.resolve(externalPath)),
+          operation: "read",
+          toolName: "read_file"
+        }
       });
     });
-  });
-  (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 testFile = path.join(tempDir, "new-file.txt");
-        const override = await tool.getApprovalOverride?.({
-          file_path: testFile,
-          content: "test"
-        });
-        (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 externalPath = "/external/project/new.ts";
-        const override = await tool.getApprovalOverride?.({
-          file_path: externalPath,
-          content: "test"
-        });
-        (0, import_vitest.expect)(override).not.toBeNull();
-        (0, import_vitest.expect)(override?.type).toBe(import_core.ApprovalType.DIRECTORY_ACCESS);
-        const metadata = override?.metadata;
-        (0, import_vitest.expect)(metadata?.operation).toBe("write");
-        (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
-        });
-        const externalPath = "/external/project/new.ts";
-        const override = await tool.getApprovalOverride?.({
-          file_path: externalPath,
-          content: "test"
-        });
-        (0, import_vitest.expect)(override).toBeNull();
-      });
+    (0, import_vitest.it)("should return null when external path is session-approved", async () => {
+      approvalManager.addApprovedDirectory("/external/project", "session");
+      const tool = (0, import_read_file_tool.createReadFileTool)(getFileSystemService);
+      const overrideFn = tool.approval?.override;
+      (0, import_vitest.expect)(overrideFn).toBeDefined();
+      const externalPath = "/external/project/file.ts";
+      const metadata = await overrideFn(
+        tool.inputSchema.parse({ file_path: externalPath }),
+        toolContext
+      );
+      (0, import_vitest.expect)(metadata).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 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"
-        );
-      });
+    (0, import_vitest.it)("should still return metadata when external path is once-approved (prompt again)", async () => {
+      approvalManager.addApprovedDirectory("/external/project", "once");
+      const tool = (0, import_read_file_tool.createReadFileTool)(getFileSystemService);
+      const overrideFn = tool.approval?.override;
+      (0, import_vitest.expect)(overrideFn).toBeDefined();
+      const externalPath = "/external/project/file.ts";
+      const metadata = await overrideFn(
+        tool.inputSchema.parse({ file_path: externalPath }),
+        toolContext
+      );
+      (0, import_vitest.expect)(metadata).not.toBeNull();
     });
   });
-  (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 testFile = path.join(tempDir, "existing.txt");
-        const override = await tool.getApprovalOverride?.({
-          file_path: testFile,
-          old_string: "old",
-          new_string: "new"
-        });
-        (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 externalPath = "/external/project/existing.ts";
-        const override = await tool.getApprovalOverride?.({
-          file_path: externalPath,
-          old_string: "old",
-          new_string: "new"
-        });
-        (0, import_vitest.expect)(override).not.toBeNull();
-        (0, import_vitest.expect)(override?.type).toBe(import_core.ApprovalType.DIRECTORY_ACCESS);
-        const metadata = override?.metadata;
-        (0, import_vitest.expect)(metadata?.operation).toBe("edit");
-        (0, import_vitest.expect)(metadata?.toolName).toBe("edit_file");
+  (0, import_vitest.describe)("Different tool operations", () => {
+    (0, import_vitest.it)("should label write operations correctly", async () => {
+      const tool = (0, import_write_file_tool.createWriteFileTool)(getFileSystemService);
+      const overrideFn = tool.approval?.override;
+      (0, import_vitest.expect)(overrideFn).toBeDefined();
+      const externalPath = "/external/project/new.ts";
+      const metadata = await overrideFn(
+        tool.inputSchema.parse({ file_path: externalPath, content: "test" }),
+        toolContext
+      );
+      (0, import_vitest.expect)(metadata).not.toBeNull();
+      (0, import_vitest.expect)(metadata).toMatchObject({
+        type: "directory_access",
+        metadata: {
+          path: path.resolve(externalPath),
+          parentDir: path.dirname(path.resolve(externalPath)),
+          operation: "write",
+          toolName: "write_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
-        });
-        const externalPath = "/external/project/existing.ts";
-        const override = await tool.getApprovalOverride?.({
+    });
+    (0, import_vitest.it)("should label edit operations correctly", async () => {
+      const tool = (0, import_edit_file_tool.createEditFileTool)(getFileSystemService);
+      const overrideFn = tool.approval?.override;
+      (0, import_vitest.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"
-        });
-        (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 externalPath1 = "/external/project/file1.ts";
-      const externalPath2 = "/external/project/file2.ts";
-      let override = await tool.getApprovalOverride?.({ file_path: externalPath1 });
-      (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"
+        }),
+        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 externalPath1 = "/external/project/file1.ts";
-      const externalPath2 = "/external/project/file2.ts";
-      let override = await tool.getApprovalOverride?.({ file_path: externalPath1 });
-      (0, import_vitest.expect)(override).not.toBeNull();
-      tool.onApprovalGranted?.({
-        approvalId: "approval-1",
-        status: import_core.ApprovalStatus.APPROVED,
-        data: { rememberDirectory: false }
+      (0, import_vitest.expect)(metadata).not.toBeNull();
+      (0, import_vitest.expect)(metadata).toMatchObject({
+        type: "directory_access",
+        metadata: {
+          path: path.resolve(externalPath),
+          parentDir: path.dirname(path.resolve(externalPath)),
+          operation: "edit",
+          toolName: "edit_file"
+        }
       });
-      (0, import_vitest.expect)(addApprovedMock).toHaveBeenCalledWith(
-        path.dirname(path.resolve(externalPath1)),
-        "once"
-      );
-      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.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"
-      });
-      (0, import_vitest.expect)(override).toBeNull();
-      override = await tool.getApprovalOverride?.({
-        file_path: "/external/project/deep/nested/file.ts"
-      });
-      (0, import_vitest.expect)(override).toBeNull();
+      const tool = (0, import_read_file_tool.createReadFileTool)(getFileSystemService);
+      const overrideFn = tool.approval?.override;
+      (0, import_vitest.expect)(overrideFn).toBeDefined();
+      approvalManager.addApprovedDirectory("/external/project", "session");
+      const metadata1 = await overrideFn(
+        tool.inputSchema.parse({ file_path: "/external/project/file.ts" }),
+        toolContext
+      );
+      (0, import_vitest.expect)(metadata1).toBeNull();
+      const metadata2 = await overrideFn(
+        tool.inputSchema.parse({ file_path: "/external/project/deep/nested/file.ts" }),
+        toolContext
+      );
+      (0, import_vitest.expect)(metadata2).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" });
-      (0, import_vitest.expect)(override).toBeNull();
-      override = await tool.getApprovalOverride?.({ file_path: "/external/other/file.ts" });
-      (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 dir1Path = "/external/project1/file.ts";
-      const dir2Path = "/external/project2/file.ts";
-      const override1 = await tool.getApprovalOverride?.({ file_path: dir1Path });
-      (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 });
-      (0, import_vitest.expect)(override2).not.toBeNull();
-      const metadata2 = override2?.metadata;
-      (0, import_vitest.expect)(metadata2?.parentDir).toBe("/external/project2");
-    });
-  });
-  (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 externalDir = "/external/project";
-      (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"
-        })
-      ).toBeNull();
-      (0, import_vitest.expect)(
-        await editTool.getApprovalOverride?.({
-          file_path: `${externalDir}/file3.ts`,
-          old_string: "a",
-          new_string: "b"
-        })
-      ).toBeNull();
+      const tool = (0, import_read_file_tool.createReadFileTool)(getFileSystemService);
+      const overrideFn = tool.approval?.override;
+      (0, import_vitest.expect)(overrideFn).toBeDefined();
+      approvalManager.addApprovedDirectory("/external/sub", "session");
+      const metadata1 = await overrideFn(
+        tool.inputSchema.parse({ file_path: "/external/sub/file.ts" }),
+        toolContext
+      );
+      (0, import_vitest.expect)(metadata1).toBeNull();
+      const metadata2 = await overrideFn(
+        tool.inputSchema.parse({ file_path: "/external/other/file.ts" }),
+        toolContext
+      );
+      (0, import_vitest.expect)(metadata2).not.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 overrideFn = tool.approval?.override;
+      (0, import_vitest.expect)(overrideFn).toBeDefined();
+      const contextWithoutApprovalManager = { logger: mockLogger };
+      await (0, import_vitest.expect)(
+        overrideFn(
+          tool.inputSchema.parse({ file_path: "/external/project/file.ts" }),
+          contextWithoutApprovalManager
+        )
+      ).rejects.toBeInstanceOf(import_core.DextoRuntimeError);
     });
   });
 });

package/dist/directory-approval.integration.test.d.ts

@@ -1,2 +1,14 @@
-
-export {  }
+/**
+ * Directory Approval Integration Tests
+ *
+ * Tests for the directory access permission system integrated into filesystem tools.
+ *
+ * Key behaviors tested:
+ * - Paths within config-allowed roots do not require directory access prompting metadata
+ * - Paths outside config-allowed roots return directory access prompting metadata
+ * - Session-approved directories do not prompt again
+ * - Once-approved directories still prompt again (prompting decision)
+ * - Session approvals cover child paths but not sibling directories
+ */
+export {};
+//# sourceMappingURL=directory-approval.integration.test.d.ts.map

package/dist/directory-approval.integration.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"directory-approval.integration.test.d.ts","sourceRoot":"","sources":["../src/directory-approval.integration.test.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG"}