@dexto/tools-filesystem 1.6.0 → 1.6.2

package/dist/directory-approval.cjs

@@ -40,50 +40,54 @@ function resolveFilePath(workingDirectory, filePath) {
 }
 function createDirectoryAccessApprovalHandlers(options) {
   return {
-    async getApprovalOverride(input, context) {
-      const resolvedFileSystemService = await options.getFileSystemService(context);
-      const paths = options.resolvePaths(input, resolvedFileSystemService);
-      const isAllowed = await resolvedFileSystemService.isPathWithinConfigAllowed(paths.path);
-      if (isAllowed) {
-        return null;
-      }
-      const approvalManager = context.services?.approval;
-      if (!approvalManager) {
-        throw import_core.ToolError.configInvalid(
-          `${options.toolName} requires ToolExecutionContext.services.approval`
+    approval: {
+      async override(input, context) {
+        const resolvedFileSystemService = await options.getFileSystemService(context);
+        const paths = options.resolvePaths(input, resolvedFileSystemService);
+        const isAllowed = await resolvedFileSystemService.isPathWithinConfigAllowed(
+          paths.path
         );
-      }
-      if (approvalManager.isDirectorySessionApproved(paths.path)) {
-        return null;
-      }
-      return {
-        type: import_core.ApprovalType.DIRECTORY_ACCESS,
-        metadata: {
-          path: paths.path,
-          parentDir: paths.parentDir,
-          operation: options.operation,
-          toolName: options.toolName
+        if (isAllowed) {
+          return null;
         }
-      };
-    },
-    onApprovalGranted(response, context, approvalRequest) {
-      if (approvalRequest.type !== import_core.ApprovalType.DIRECTORY_ACCESS) {
-        return;
-      }
-      const metadata = approvalRequest.metadata;
-      const parentDir = typeof metadata?.parentDir === "string" ? metadata.parentDir : null;
-      if (!parentDir) {
-        return;
-      }
-      const data = response.data;
-      const rememberDirectory = data?.rememberDirectory ?? false;
-      const approvalManager = context.services?.approval;
-      if (!approvalManager) {
-        throw import_core.ToolError.configInvalid(
-          `${options.toolName} requires ToolExecutionContext.services.approval`
+        const approvalManager = context.services?.approval;
+        if (!approvalManager) {
+          throw import_core.ToolError.configInvalid(
+            `${options.toolName} requires ToolExecutionContext.services.approval`
+          );
+        }
+        if (approvalManager.isDirectorySessionApproved(paths.path)) {
+          return null;
+        }
+        return {
+          type: import_core.ApprovalType.DIRECTORY_ACCESS,
+          metadata: {
+            path: paths.path,
+            parentDir: paths.parentDir,
+            operation: options.operation,
+            toolName: options.toolName
+          }
+        };
+      },
+      async onGranted(response, context, approvalRequest) {
+        const approvalManager = context.services?.approval;
+        if (!approvalManager) {
+          return;
+        }
+        if (response.status !== import_core.ApprovalStatus.APPROVED) {
+          return;
+        }
+        const data = response.data;
+        const rememberDirectory = data?.rememberDirectory ?? false;
+        const metadata = approvalRequest.metadata;
+        if (!metadata?.parentDir) {
+          return;
+        }
+        approvalManager.addApprovedDirectory(
+          metadata.parentDir,
+          rememberDirectory ? "session" : "once"
         );
       }
-      approvalManager.addApprovedDirectory(parentDir, rememberDirectory ? "session" : "once");
     }
   };
 }

package/dist/directory-approval.d.ts

@@ -1,3 +1,4 @@
+import type { z, ZodTypeAny } from 'zod';
 import type { ApprovalRequestDetails, ApprovalResponse, ToolExecutionContext } from '@dexto/core';
 import type { FileSystemService } from './filesystem-service.js';
 import type { FileSystemServiceGetter } from './file-tool-types.js';
@@ -7,14 +8,17 @@ type DirectoryApprovalPaths = {
     parentDir: string;
 };
 export declare function resolveFilePath(workingDirectory: string, filePath: string): DirectoryApprovalPaths;
-export declare function createDirectoryAccessApprovalHandlers<TInput>(options: {
+export declare function createDirectoryAccessApprovalHandlers<const TSchema extends ZodTypeAny>(options: {
     toolName: string;
     operation: DirectoryApprovalOperation;
+    inputSchema: TSchema;
     getFileSystemService: FileSystemServiceGetter;
-    resolvePaths: (input: TInput, fileSystemService: FileSystemService) => DirectoryApprovalPaths;
+    resolvePaths: (input: z.output<TSchema>, fileSystemService: FileSystemService) => DirectoryApprovalPaths;
 }): {
-    getApprovalOverride: (input: TInput, context: ToolExecutionContext) => Promise<ApprovalRequestDetails | null>;
-    onApprovalGranted: (response: ApprovalResponse, context: ToolExecutionContext, approvalRequest: ApprovalRequestDetails) => void;
+    approval: {
+        override: (input: z.output<TSchema>, context: ToolExecutionContext) => Promise<ApprovalRequestDetails | null>;
+        onGranted: (response: ApprovalResponse, context: ToolExecutionContext, approvalRequest: ApprovalRequestDetails) => Promise<void>;
+    };
 };
 export {};
 //# sourceMappingURL=directory-approval.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"directory-approval.d.ts","sourceRoot":"","sources":["../src/directory-approval.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAClG,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AACjE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAEpE,KAAK,0BAA0B,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;AAE5D,KAAK,sBAAsB,GAAG;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,wBAAgB,eAAe,CAC3B,gBAAgB,EAAE,MAAM,EACxB,QAAQ,EAAE,MAAM,GACjB,sBAAsB,CAKxB;AAED,wBAAgB,qCAAqC,CAAC,MAAM,EAAE,OAAO,EAAE;IACnE,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,0BAA0B,CAAC;IACtC,oBAAoB,EAAE,uBAAuB,CAAC;IAC9C,YAAY,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,iBAAiB,EAAE,iBAAiB,KAAK,sBAAsB,CAAC;CACjG,GAAG;IACA,mBAAmB,EAAE,CACjB,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,oBAAoB,KAC5B,OAAO,CAAC,sBAAsB,GAAG,IAAI,CAAC,CAAC;IAC5C,iBAAiB,EAAE,CACf,QAAQ,EAAE,gBAAgB,EAC1B,OAAO,EAAE,oBAAoB,EAC7B,eAAe,EAAE,sBAAsB,KACtC,IAAI,CAAC;CACb,CA+DA"}
+{"version":3,"file":"directory-approval.d.ts","sourceRoot":"","sources":["../src/directory-approval.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,CAAC,EAAE,UAAU,EAAE,MAAM,KAAK,CAAC;AAEzC,OAAO,KAAK,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAClG,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AACjE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAEpE,KAAK,0BAA0B,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;AAE5D,KAAK,sBAAsB,GAAG;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,wBAAgB,eAAe,CAC3B,gBAAgB,EAAE,MAAM,EACxB,QAAQ,EAAE,MAAM,GACjB,sBAAsB,CAKxB;AAED,wBAAgB,qCAAqC,CAAC,KAAK,CAAC,OAAO,SAAS,UAAU,EAAE,OAAO,EAAE;IAC7F,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,0BAA0B,CAAC;IACtC,WAAW,EAAE,OAAO,CAAC;IACrB,oBAAoB,EAAE,uBAAuB,CAAC;IAC9C,YAAY,EAAE,CACV,KAAK,EAAE,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,EACxB,iBAAiB,EAAE,iBAAiB,KACnC,sBAAsB,CAAC;CAC/B,GAAG;IACA,QAAQ,EAAE;QACN,QAAQ,EAAE,CACN,KAAK,EAAE,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,EACxB,OAAO,EAAE,oBAAoB,KAC5B,OAAO,CAAC,sBAAsB,GAAG,IAAI,CAAC,CAAC;QAC5C,SAAS,EAAE,CACP,QAAQ,EAAE,gBAAgB,EAC1B,OAAO,EAAE,oBAAoB,EAC7B,eAAe,EAAE,sBAAsB,KACtC,OAAO,CAAC,IAAI,CAAC,CAAC;KACtB,CAAC;CACL,CA4DA"}

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

@@ -25,11 +25,11 @@ 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 = () => {
   const noopAsync = async () => void 0;
   const logger = {
@@ -40,6 +40,7 @@ const createMockLogger = () => {
     error: import_vitest.vi.fn(),
     trackException: import_vitest.vi.fn(),
     createChild: () => logger,
+    createFileOnlyChild: () => logger,
     setLevel: import_vitest.vi.fn(),
     getLevel: () => "info",
     getLogFilePath: () => null,
@@ -100,402 +101,152 @@ function createToolContext(logger, approval) {
     } 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)(getFileSystemService);
-        const testFile = path.join(tempDir, "test.txt");
-        await fs.writeFile(testFile, "test content");
-        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)(getFileSystemService);
-        const externalPath = "/external/project/file.ts";
-        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;
-        (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 () => {
-        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?.(
-          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)(getFileSystemService);
-        const externalPath = "/external/project/file.ts";
-        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)(getFileSystemService);
-        const externalPath = "/external/project/file.ts";
-        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)(getFileSystemService);
-        const externalPath = "/external/project/file.ts";
-        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: {}
-          },
-          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)(getFileSystemService);
-        const testFile = path.join(tempDir, "readable.txt");
-        await fs.writeFile(testFile, "Hello, world!\nLine 2");
-        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);
-      });
-    });
-  });
-  (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)(getFileSystemService);
-        const testFile = path.join(tempDir, "new-file.txt");
-        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)(getFileSystemService);
-        const externalPath = "/external/project/new.ts";
-        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;
-        (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 () => {
-        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?.(
-          tool.inputSchema.parse({ file_path: externalPath, content: "test" }),
-          toolContext
-        );
-        (0, import_vitest.expect)(override).toBeNull();
-      });
+  (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)("onApprovalGranted", () => {
-      (0, import_vitest.it)("should add directory as session-approved when rememberDirectory is true", async () => {
-        const tool = (0, import_write_file_tool.createWriteFileTool)(getFileSystemService);
-        const externalPath = "/external/project/new.ts";
-        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");
+    (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"
         }
-        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)(getFileSystemService);
-        const testFile = path.join(tempDir, "existing.txt");
-        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)(getFileSystemService);
-        const externalPath = "/external/project/existing.ts";
-        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;
-        (0, import_vitest.expect)(metadata?.operation).toBe("edit");
-        (0, import_vitest.expect)(metadata?.toolName).toBe("edit_file");
-      });
-      (0, import_vitest.it)("should return null when external path is session-approved", async () => {
-        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?.(
-          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 () => {
+    (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 externalPath1 = "/external/project/file1.ts";
-      const externalPath2 = "/external/project/file2.ts";
-      let override = await tool.getApprovalOverride?.(
-        tool.inputSchema.parse({ file_path: externalPath1 }),
+      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)(override).not.toBeNull();
-      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
-      );
-      (0, import_vitest.expect)(override).toBeNull();
+      (0, import_vitest.expect)(metadata).toBeNull();
     });
-    (0, import_vitest.it)("should prompt for subsequent requests after once approval", async () => {
+    (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 externalPath1 = "/external/project/file1.ts";
-      const externalPath2 = "/external/project/file2.ts";
-      let override = await tool.getApprovalOverride?.(
-        tool.inputSchema.parse({ file_path: externalPath1 }),
+      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)(override).not.toBeNull();
-      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)(metadata).not.toBeNull();
+    });
+  });
+  (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)(
-        approvalManager.getApprovedDirectories().get(path.dirname(path.resolve(externalPath1)))
-      ).toBe("once");
-      override = await tool.getApprovalOverride?.(
-        tool.inputSchema.parse({ file_path: externalPath2 }),
+      (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 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"
+        }),
         toolContext
       );
-      (0, import_vitest.expect)(override).not.toBeNull();
+      (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.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)(getFileSystemService);
+      const overrideFn = tool.approval?.override;
+      (0, import_vitest.expect)(overrideFn).toBeDefined();
       approvalManager.addApprovedDirectory("/external/project", "session");
-      let override = await tool.getApprovalOverride?.(
+      const metadata1 = await overrideFn(
         tool.inputSchema.parse({ file_path: "/external/project/file.ts" }),
         toolContext
       );
-      (0, import_vitest.expect)(override).toBeNull();
-      override = await tool.getApprovalOverride?.(
+      (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)(override).toBeNull();
+      (0, import_vitest.expect)(metadata2).toBeNull();
     });
     (0, import_vitest.it)("should NOT cover sibling directories", async () => {
       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");
-      let override = await tool.getApprovalOverride?.(
+      const metadata1 = await overrideFn(
         tool.inputSchema.parse({ file_path: "/external/sub/file.ts" }),
         toolContext
       );
-      (0, import_vitest.expect)(override).toBeNull();
-      override = await tool.getApprovalOverride?.(
+      (0, import_vitest.expect)(metadata1).toBeNull();
+      const metadata2 = await overrideFn(
         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)(getFileSystemService);
-      const dir1Path = "/external/project1/file.ts";
-      const dir2Path = "/external/project2/file.ts";
-      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?.(
-        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");
-    });
-  });
-  (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)(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 writeTool.getApprovalOverride?.(
-          writeTool.inputSchema.parse({
-            file_path: `${externalDir}/file2.ts`,
-            content: "test"
-          }),
-          toolContext
-        )
-      ).toBeNull();
-      (0, import_vitest.expect)(
-        await editTool.getApprovalOverride?.(
-          editTool.inputSchema.parse({
-            file_path: `${externalDir}/file3.ts`,
-            old_string: "a",
-            new_string: "b"
-          }),
-          toolContext
-        )
-      ).toBeNull();
+      (0, import_vitest.expect)(metadata2).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)(
-        tool.getApprovalOverride?.(
+        overrideFn(
           tool.inputSchema.parse({ file_path: "/external/project/file.ts" }),
           contextWithoutApprovalManager
         )