@dexto/tools-filesystem 1.5.2 → 1.5.4

package/dist/filesystem-service.js

@@ -33,6 +33,13 @@ class FileSystemService {
   getBackupDir() {
     return this.config.backupPath || getDextoPath("backups");
   }
+  /**
+   * Get the effective working directory for file operations.
+   * Falls back to process.cwd() if not configured.
+   */
+  getWorkingDirectory() {
+    return this.config.workingDirectory || process.cwd();
+  }
   /**
    * Initialize the service.
    * Safe to call multiple times - subsequent calls return the same promise.
@@ -93,7 +100,7 @@ class FileSystemService {
    * @param filePath The file path to check (can be relative or absolute)
    * @returns true if the path is within config-allowed paths, false otherwise
    */
-  isPathWithinConfigAllowed(filePath) {
+  async isPathWithinConfigAllowed(filePath) {
     return this.pathValidator.isPathWithinAllowed(filePath);
   }
   /**
@@ -101,7 +108,7 @@ class FileSystemService {
    */
   async readFile(filePath, options = {}) {
     await this.ensureInitialized();
-    const validation = this.pathValidator.validatePath(filePath);
+    const validation = await this.pathValidator.validatePath(filePath);
     if (!validation.isValid || !validation.normalizedPath) {
       throw FileSystemError.invalidPath(filePath, validation.error || "Unknown error");
     }
@@ -178,7 +185,7 @@ class FileSystemService {
       });
       const validFiles = [];
       for (const file of files) {
-        const validation = this.pathValidator.validatePath(file);
+        const validation = await this.pathValidator.validatePath(file);
         if (!validation.isValid || !validation.normalizedPath) {
           this.logger.debug(`Skipping invalid path: ${file}`);
           continue;
@@ -311,7 +318,7 @@ class FileSystemService {
    */
   async writeFile(filePath, content, options = {}) {
     await this.ensureInitialized();
-    const validation = this.pathValidator.validatePath(filePath);
+    const validation = await this.pathValidator.validatePath(filePath);
     if (!validation.isValid || !validation.normalizedPath) {
       throw FileSystemError.invalidPath(filePath, validation.error || "Unknown error");
     }
@@ -353,14 +360,14 @@ class FileSystemService {
    */
   async editFile(filePath, operation, options = {}) {
     await this.ensureInitialized();
-    const validation = this.pathValidator.validatePath(filePath);
+    const validation = await this.pathValidator.validatePath(filePath);
     if (!validation.isValid || !validation.normalizedPath) {
       throw FileSystemError.invalidPath(filePath, validation.error || "Unknown error");
     }
     const normalizedPath = validation.normalizedPath;
     const fileContent = await this.readFile(normalizedPath);
-    let content = fileContent.content;
-    const occurrences = (content.match(
+    const originalContent = fileContent.content;
+    const occurrences = (originalContent.match(
       new RegExp(operation.oldString.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g")
     ) || []).length;
     if (occurrences === 0) {
@@ -374,21 +381,24 @@ class FileSystemService {
       backupPath = await this.createBackup(normalizedPath);
     }
     try {
+      let newContent;
       if (operation.replaceAll) {
-        content = content.replace(
+        newContent = originalContent.replace(
           new RegExp(operation.oldString.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g"),
           operation.newString
         );
       } else {
-        content = content.replace(operation.oldString, operation.newString);
+        newContent = originalContent.replace(operation.oldString, operation.newString);
       }
-      await fs.writeFile(normalizedPath, content, options.encoding || DEFAULT_ENCODING);
+      await fs.writeFile(normalizedPath, newContent, options.encoding || DEFAULT_ENCODING);
       this.logger.debug(`File edited: ${normalizedPath} (${occurrences} replacements)`);
       return {
         success: true,
         path: normalizedPath,
         changesCount: occurrences,
-        backupPath
+        backupPath,
+        originalContent,
+        newContent
       };
     } catch (error) {
       throw FileSystemError.editFailed(
@@ -480,10 +490,10 @@ class FileSystemService {
     return { ...this.config };
   }
   /**
-   * Check if a path is allowed
+   * Check if a path is allowed (async for non-blocking symlink resolution)
    */
-  isPathAllowed(filePath) {
-    const validation = this.pathValidator.validatePath(filePath);
+  async isPathAllowed(filePath) {
+    const validation = await this.pathValidator.validatePath(filePath);
     return validation.isValid;
   }
 }

package/dist/filesystem-service.test.cjs

@@ -0,0 +1,233 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+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_filesystem_service = require("./filesystem-service.js");
+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()
+});
+(0, import_vitest.describe)("FileSystemService", () => {
+  let mockLogger;
+  let tempDir;
+  (0, import_vitest.beforeEach)(async () => {
+    mockLogger = createMockLogger();
+    const rawTempDir = await fs.mkdtemp(path.join(os.tmpdir(), "dexto-fs-test-"));
+    tempDir = await fs.realpath(rawTempDir);
+    import_vitest.vi.clearAllMocks();
+  });
+  (0, import_vitest.afterEach)(async () => {
+    try {
+      await fs.rm(tempDir, { recursive: true, force: true });
+    } catch {
+    }
+  });
+  (0, import_vitest.describe)("Backup Behavior", () => {
+    (0, import_vitest.describe)("writeFile", () => {
+      (0, import_vitest.it)("should NOT create backup when enableBackups is false (default)", async () => {
+        const fileSystemService = new import_filesystem_service.FileSystemService(
+          {
+            allowedPaths: [tempDir],
+            blockedPaths: [],
+            blockedExtensions: [],
+            maxFileSize: 10 * 1024 * 1024,
+            workingDirectory: tempDir,
+            enableBackups: false,
+            backupRetentionDays: 7
+          },
+          mockLogger
+        );
+        await fileSystemService.initialize();
+        const testFile = path.join(tempDir, "test.txt");
+        await fs.writeFile(testFile, "original content");
+        const result = await fileSystemService.writeFile(testFile, "new content");
+        (0, import_vitest.expect)(result.success).toBe(true);
+        (0, import_vitest.expect)(result.backupPath).toBeUndefined();
+        const backupDir = path.join(tempDir, ".dexto-backups");
+        try {
+          const files = await fs.readdir(backupDir);
+          (0, import_vitest.expect)(files.length).toBe(0);
+        } catch {
+        }
+      });
+      (0, import_vitest.it)("should create backup when enableBackups is true", async () => {
+        const fileSystemService = new import_filesystem_service.FileSystemService(
+          {
+            allowedPaths: [tempDir],
+            blockedPaths: [],
+            blockedExtensions: [],
+            maxFileSize: 10 * 1024 * 1024,
+            workingDirectory: tempDir,
+            enableBackups: true,
+            backupRetentionDays: 7
+          },
+          mockLogger
+        );
+        await fileSystemService.initialize();
+        const testFile = path.join(tempDir, "test.txt");
+        await fs.writeFile(testFile, "original content");
+        const result = await fileSystemService.writeFile(testFile, "new content");
+        (0, import_vitest.expect)(result.success).toBe(true);
+        (0, import_vitest.expect)(result.backupPath).toBeDefined();
+        (0, import_vitest.expect)(result.backupPath).toContain(".dexto");
+        (0, import_vitest.expect)(result.backupPath).toContain("backup");
+        const backupContent = await fs.readFile(result.backupPath, "utf-8");
+        (0, import_vitest.expect)(backupContent).toBe("original content");
+        const newContent = await fs.readFile(testFile, "utf-8");
+        (0, import_vitest.expect)(newContent).toBe("new content");
+      });
+      (0, import_vitest.it)("should NOT create backup for new files even when enableBackups is true", async () => {
+        const fileSystemService = new import_filesystem_service.FileSystemService(
+          {
+            allowedPaths: [tempDir],
+            blockedPaths: [],
+            blockedExtensions: [],
+            maxFileSize: 10 * 1024 * 1024,
+            workingDirectory: tempDir,
+            enableBackups: true,
+            backupRetentionDays: 7
+          },
+          mockLogger
+        );
+        await fileSystemService.initialize();
+        const testFile = path.join(tempDir, "new-file.txt");
+        const result = await fileSystemService.writeFile(testFile, "content", {
+          createDirs: true
+        });
+        (0, import_vitest.expect)(result.success).toBe(true);
+        (0, import_vitest.expect)(result.backupPath).toBeUndefined();
+      });
+      (0, import_vitest.it)("should respect per-call backup option over config", async () => {
+        const fileSystemService = new import_filesystem_service.FileSystemService(
+          {
+            allowedPaths: [tempDir],
+            blockedPaths: [],
+            blockedExtensions: [],
+            maxFileSize: 10 * 1024 * 1024,
+            workingDirectory: tempDir,
+            enableBackups: false,
+            // Config says no backups
+            backupRetentionDays: 7
+          },
+          mockLogger
+        );
+        await fileSystemService.initialize();
+        const testFile = path.join(tempDir, "test.txt");
+        await fs.writeFile(testFile, "original content");
+        const result = await fileSystemService.writeFile(testFile, "new content", {
+          backup: true
+        });
+        (0, import_vitest.expect)(result.success).toBe(true);
+        (0, import_vitest.expect)(result.backupPath).toBeDefined();
+      });
+    });
+    (0, import_vitest.describe)("editFile", () => {
+      (0, import_vitest.it)("should NOT create backup when enableBackups is false (default)", async () => {
+        const fileSystemService = new import_filesystem_service.FileSystemService(
+          {
+            allowedPaths: [tempDir],
+            blockedPaths: [],
+            blockedExtensions: [],
+            maxFileSize: 10 * 1024 * 1024,
+            workingDirectory: tempDir,
+            enableBackups: false,
+            backupRetentionDays: 7
+          },
+          mockLogger
+        );
+        await fileSystemService.initialize();
+        const testFile = path.join(tempDir, "test.txt");
+        await fs.writeFile(testFile, "hello world");
+        const result = await fileSystemService.editFile(testFile, {
+          oldString: "world",
+          newString: "universe"
+        });
+        (0, import_vitest.expect)(result.success).toBe(true);
+        (0, import_vitest.expect)(result.backupPath).toBeUndefined();
+        const content = await fs.readFile(testFile, "utf-8");
+        (0, import_vitest.expect)(content).toBe("hello universe");
+      });
+      (0, import_vitest.it)("should create backup when enableBackups is true", async () => {
+        const fileSystemService = new import_filesystem_service.FileSystemService(
+          {
+            allowedPaths: [tempDir],
+            blockedPaths: [],
+            blockedExtensions: [],
+            maxFileSize: 10 * 1024 * 1024,
+            workingDirectory: tempDir,
+            enableBackups: true,
+            backupRetentionDays: 7
+          },
+          mockLogger
+        );
+        await fileSystemService.initialize();
+        const testFile = path.join(tempDir, "test.txt");
+        await fs.writeFile(testFile, "hello world");
+        const result = await fileSystemService.editFile(testFile, {
+          oldString: "world",
+          newString: "universe"
+        });
+        (0, import_vitest.expect)(result.success).toBe(true);
+        (0, import_vitest.expect)(result.backupPath).toBeDefined();
+        const backupContent = await fs.readFile(result.backupPath, "utf-8");
+        (0, import_vitest.expect)(backupContent).toBe("hello world");
+        const content = await fs.readFile(testFile, "utf-8");
+        (0, import_vitest.expect)(content).toBe("hello universe");
+      });
+      (0, import_vitest.it)("should respect per-call backup option over config", async () => {
+        const fileSystemService = new import_filesystem_service.FileSystemService(
+          {
+            allowedPaths: [tempDir],
+            blockedPaths: [],
+            blockedExtensions: [],
+            maxFileSize: 10 * 1024 * 1024,
+            workingDirectory: tempDir,
+            enableBackups: false,
+            // Config says no backups
+            backupRetentionDays: 7
+          },
+          mockLogger
+        );
+        await fileSystemService.initialize();
+        const testFile = path.join(tempDir, "test.txt");
+        await fs.writeFile(testFile, "hello world");
+        const result = await fileSystemService.editFile(
+          testFile,
+          {
+            oldString: "world",
+            newString: "universe"
+          },
+          { backup: true }
+        );
+        (0, import_vitest.expect)(result.success).toBe(true);
+        (0, import_vitest.expect)(result.backupPath).toBeDefined();
+      });
+    });
+  });
+});

package/dist/filesystem-service.test.d.cts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/filesystem-service.test.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/filesystem-service.test.js

@@ -0,0 +1,210 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import * as path from "node:path";
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import { FileSystemService } from "./filesystem-service.js";
+const createMockLogger = () => ({
+  debug: vi.fn(),
+  info: vi.fn(),
+  warn: vi.fn(),
+  error: vi.fn(),
+  createChild: vi.fn().mockReturnThis()
+});
+describe("FileSystemService", () => {
+  let mockLogger;
+  let tempDir;
+  beforeEach(async () => {
+    mockLogger = createMockLogger();
+    const rawTempDir = await fs.mkdtemp(path.join(os.tmpdir(), "dexto-fs-test-"));
+    tempDir = await fs.realpath(rawTempDir);
+    vi.clearAllMocks();
+  });
+  afterEach(async () => {
+    try {
+      await fs.rm(tempDir, { recursive: true, force: true });
+    } catch {
+    }
+  });
+  describe("Backup Behavior", () => {
+    describe("writeFile", () => {
+      it("should NOT create backup when enableBackups is false (default)", async () => {
+        const fileSystemService = new FileSystemService(
+          {
+            allowedPaths: [tempDir],
+            blockedPaths: [],
+            blockedExtensions: [],
+            maxFileSize: 10 * 1024 * 1024,
+            workingDirectory: tempDir,
+            enableBackups: false,
+            backupRetentionDays: 7
+          },
+          mockLogger
+        );
+        await fileSystemService.initialize();
+        const testFile = path.join(tempDir, "test.txt");
+        await fs.writeFile(testFile, "original content");
+        const result = await fileSystemService.writeFile(testFile, "new content");
+        expect(result.success).toBe(true);
+        expect(result.backupPath).toBeUndefined();
+        const backupDir = path.join(tempDir, ".dexto-backups");
+        try {
+          const files = await fs.readdir(backupDir);
+          expect(files.length).toBe(0);
+        } catch {
+        }
+      });
+      it("should create backup when enableBackups is true", async () => {
+        const fileSystemService = new FileSystemService(
+          {
+            allowedPaths: [tempDir],
+            blockedPaths: [],
+            blockedExtensions: [],
+            maxFileSize: 10 * 1024 * 1024,
+            workingDirectory: tempDir,
+            enableBackups: true,
+            backupRetentionDays: 7
+          },
+          mockLogger
+        );
+        await fileSystemService.initialize();
+        const testFile = path.join(tempDir, "test.txt");
+        await fs.writeFile(testFile, "original content");
+        const result = await fileSystemService.writeFile(testFile, "new content");
+        expect(result.success).toBe(true);
+        expect(result.backupPath).toBeDefined();
+        expect(result.backupPath).toContain(".dexto");
+        expect(result.backupPath).toContain("backup");
+        const backupContent = await fs.readFile(result.backupPath, "utf-8");
+        expect(backupContent).toBe("original content");
+        const newContent = await fs.readFile(testFile, "utf-8");
+        expect(newContent).toBe("new content");
+      });
+      it("should NOT create backup for new files even when enableBackups is true", async () => {
+        const fileSystemService = new FileSystemService(
+          {
+            allowedPaths: [tempDir],
+            blockedPaths: [],
+            blockedExtensions: [],
+            maxFileSize: 10 * 1024 * 1024,
+            workingDirectory: tempDir,
+            enableBackups: true,
+            backupRetentionDays: 7
+          },
+          mockLogger
+        );
+        await fileSystemService.initialize();
+        const testFile = path.join(tempDir, "new-file.txt");
+        const result = await fileSystemService.writeFile(testFile, "content", {
+          createDirs: true
+        });
+        expect(result.success).toBe(true);
+        expect(result.backupPath).toBeUndefined();
+      });
+      it("should respect per-call backup option over config", async () => {
+        const fileSystemService = new FileSystemService(
+          {
+            allowedPaths: [tempDir],
+            blockedPaths: [],
+            blockedExtensions: [],
+            maxFileSize: 10 * 1024 * 1024,
+            workingDirectory: tempDir,
+            enableBackups: false,
+            // Config says no backups
+            backupRetentionDays: 7
+          },
+          mockLogger
+        );
+        await fileSystemService.initialize();
+        const testFile = path.join(tempDir, "test.txt");
+        await fs.writeFile(testFile, "original content");
+        const result = await fileSystemService.writeFile(testFile, "new content", {
+          backup: true
+        });
+        expect(result.success).toBe(true);
+        expect(result.backupPath).toBeDefined();
+      });
+    });
+    describe("editFile", () => {
+      it("should NOT create backup when enableBackups is false (default)", async () => {
+        const fileSystemService = new FileSystemService(
+          {
+            allowedPaths: [tempDir],
+            blockedPaths: [],
+            blockedExtensions: [],
+            maxFileSize: 10 * 1024 * 1024,
+            workingDirectory: tempDir,
+            enableBackups: false,
+            backupRetentionDays: 7
+          },
+          mockLogger
+        );
+        await fileSystemService.initialize();
+        const testFile = path.join(tempDir, "test.txt");
+        await fs.writeFile(testFile, "hello world");
+        const result = await fileSystemService.editFile(testFile, {
+          oldString: "world",
+          newString: "universe"
+        });
+        expect(result.success).toBe(true);
+        expect(result.backupPath).toBeUndefined();
+        const content = await fs.readFile(testFile, "utf-8");
+        expect(content).toBe("hello universe");
+      });
+      it("should create backup when enableBackups is true", async () => {
+        const fileSystemService = new FileSystemService(
+          {
+            allowedPaths: [tempDir],
+            blockedPaths: [],
+            blockedExtensions: [],
+            maxFileSize: 10 * 1024 * 1024,
+            workingDirectory: tempDir,
+            enableBackups: true,
+            backupRetentionDays: 7
+          },
+          mockLogger
+        );
+        await fileSystemService.initialize();
+        const testFile = path.join(tempDir, "test.txt");
+        await fs.writeFile(testFile, "hello world");
+        const result = await fileSystemService.editFile(testFile, {
+          oldString: "world",
+          newString: "universe"
+        });
+        expect(result.success).toBe(true);
+        expect(result.backupPath).toBeDefined();
+        const backupContent = await fs.readFile(result.backupPath, "utf-8");
+        expect(backupContent).toBe("hello world");
+        const content = await fs.readFile(testFile, "utf-8");
+        expect(content).toBe("hello universe");
+      });
+      it("should respect per-call backup option over config", async () => {
+        const fileSystemService = new FileSystemService(
+          {
+            allowedPaths: [tempDir],
+            blockedPaths: [],
+            blockedExtensions: [],
+            maxFileSize: 10 * 1024 * 1024,
+            workingDirectory: tempDir,
+            enableBackups: false,
+            // Config says no backups
+            backupRetentionDays: 7
+          },
+          mockLogger
+        );
+        await fileSystemService.initialize();
+        const testFile = path.join(tempDir, "test.txt");
+        await fs.writeFile(testFile, "hello world");
+        const result = await fileSystemService.editFile(
+          testFile,
+          {
+            oldString: "world",
+            newString: "universe"
+          },
+          { backup: true }
+        );
+        expect(result.success).toBe(true);
+        expect(result.backupPath).toBeDefined();
+      });
+    });
+  });
+});

package/dist/glob-files-tool.cjs

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,27 +17,78 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var glob_files_tool_exports = {};
 __export(glob_files_tool_exports, {
   createGlobFilesTool: () => createGlobFilesTool
 });
 module.exports = __toCommonJS(glob_files_tool_exports);
+var path = __toESM(require("node:path"), 1);
 var import_zod = require("zod");
+var import_core = require("@dexto/core");
 const GlobFilesInputSchema = import_zod.z.object({
   pattern: import_zod.z.string().describe('Glob pattern to match files (e.g., "**/*.ts", "src/**/*.js")'),
   path: import_zod.z.string().optional().describe("Base directory to search from (defaults to working directory)"),
   max_results: import_zod.z.number().int().positive().optional().default(1e3).describe("Maximum number of results to return (default: 1000)")
 }).strict();
-function createGlobFilesTool(fileSystemService) {
+function createGlobFilesTool(options) {
+  const { fileSystemService, directoryApproval } = options;
+  let pendingApprovalSearchDir;
   return {
     id: "glob_files",
     description: "Find files matching a glob pattern. Supports standard glob syntax like **/*.js for recursive matches, *.ts for files in current directory, and src/**/*.tsx for nested paths. Returns array of file paths with metadata (size, modified date). Results are limited to allowed paths only.",
     inputSchema: GlobFilesInputSchema,
+    /**
+     * Check if this glob operation needs directory access approval.
+     * Returns custom approval request if the search directory is outside allowed paths.
+     */
+    getApprovalOverride: async (args) => {
+      const { path: searchPath } = args;
+      const baseDir = fileSystemService.getWorkingDirectory();
+      const searchDir = path.resolve(baseDir, searchPath || ".");
+      const isAllowed = await fileSystemService.isPathWithinConfigAllowed(searchDir);
+      if (isAllowed) {
+        return null;
+      }
+      if (directoryApproval?.isSessionApproved(searchDir)) {
+        return null;
+      }
+      pendingApprovalSearchDir = searchDir;
+      return {
+        type: import_core.ApprovalType.DIRECTORY_ACCESS,
+        metadata: {
+          path: searchDir,
+          parentDir: searchDir,
+          operation: "search",
+          toolName: "glob_files"
+        }
+      };
+    },
+    /**
+     * Handle approved directory access - remember the directory for session
+     */
+    onApprovalGranted: (response) => {
+      if (!directoryApproval || !pendingApprovalSearchDir) return;
+      const data = response.data;
+      const rememberDirectory = data?.rememberDirectory ?? false;
+      directoryApproval.addApproved(
+        pendingApprovalSearchDir,
+        rememberDirectory ? "session" : "once"
+      );
+      pendingApprovalSearchDir = void 0;
+    },
     execute: async (input, _context) => {
-      const { pattern, path, max_results } = input;
+      const { pattern, path: path2, max_results } = input;
       const result = await fileSystemService.globFiles(pattern, {
-        cwd: path,
+        cwd: path2,
         maxResults: max_results,
         includeMetadata: true
       });

package/dist/glob-files-tool.d.cts

@@ -1,5 +1,6 @@
 import { InternalTool } from '@dexto/core';
-import { FileSystemService } from './filesystem-service.cjs';
+import { FileToolOptions } from './file-tool-types.cjs';
+import './filesystem-service.cjs';
 import './types.cjs';
 
 /**
@@ -9,8 +10,8 @@ import './types.cjs';
  */
 
 /**
- * Create the glob_files internal tool
+ * Create the glob_files internal tool with directory approval support
  */
-declare function createGlobFilesTool(fileSystemService: FileSystemService): InternalTool;
+declare function createGlobFilesTool(options: FileToolOptions): InternalTool;
 
 export { createGlobFilesTool };