@dexto/tools-filesystem 1.5.8 → 1.6.0

package/dist/edit-file-tool.test.cjs

@@ -29,13 +29,25 @@ var import_edit_file_tool = require("./edit-file-tool.js");
 var import_filesystem_service = require("./filesystem-service.js");
 var import_core = require("@dexto/core");
 var import_core2 = 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 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: import_vitest.vi.fn(() => logger),
+    setLevel: import_vitest.vi.fn(),
+    getLevel: import_vitest.vi.fn(() => "debug"),
+    getLogFilePath: import_vitest.vi.fn(() => null),
+    destroy: import_vitest.vi.fn(async () => void 0)
+  };
+  return logger;
+};
+function createToolContext(logger, overrides = {}) {
+  return { logger, ...overrides };
+}
 (0, import_vitest.describe)("edit_file tool", () => {
   let mockLogger;
   let tempDir;
@@ -67,7 +79,7 @@ const createMockLogger = () => ({
   });
   (0, import_vitest.describe)("File Modification Detection", () => {
     (0, import_vitest.it)("should succeed when file is not modified between preview and execute", async () => {
-      const tool = (0, import_edit_file_tool.createEditFileTool)({ fileSystemService });
+      const tool = (0, import_edit_file_tool.createEditFileTool)(async () => fileSystemService);
       const testFile = path.join(tempDir, "test.txt");
       await fs.writeFile(testFile, "hello world");
       const toolCallId = "test-call-123";
@@ -76,16 +88,23 @@ const createMockLogger = () => ({
         old_string: "world",
         new_string: "universe"
       };
-      const preview = await tool.generatePreview(input, { toolCallId });
+      const parsedInput = tool.inputSchema.parse(input);
+      const preview = await tool.generatePreview(
+        parsedInput,
+        createToolContext(mockLogger, { toolCallId })
+      );
       (0, import_vitest.expect)(preview).toBeDefined();
-      const result = await tool.execute(input, { toolCallId });
+      const result = await tool.execute(
+        parsedInput,
+        createToolContext(mockLogger, { toolCallId })
+      );
       (0, import_vitest.expect)(result.success).toBe(true);
       (0, import_vitest.expect)(result.path).toBe(testFile);
       const content = await fs.readFile(testFile, "utf-8");
       (0, import_vitest.expect)(content).toBe("hello universe");
     });
     (0, import_vitest.it)("should fail when file is modified between preview and execute", async () => {
-      const tool = (0, import_edit_file_tool.createEditFileTool)({ fileSystemService });
+      const tool = (0, import_edit_file_tool.createEditFileTool)(async () => fileSystemService);
       const testFile = path.join(tempDir, "test.txt");
       await fs.writeFile(testFile, "hello world");
       const toolCallId = "test-call-456";
@@ -94,11 +113,15 @@ const createMockLogger = () => ({
         old_string: "world",
         new_string: "universe"
       };
-      const preview = await tool.generatePreview(input, { toolCallId });
+      const parsedInput = tool.inputSchema.parse(input);
+      const preview = await tool.generatePreview(
+        parsedInput,
+        createToolContext(mockLogger, { toolCallId })
+      );
       (0, import_vitest.expect)(preview).toBeDefined();
       await fs.writeFile(testFile, "hello world - user added this");
       try {
-        await tool.execute(input, { toolCallId });
+        await tool.execute(parsedInput, createToolContext(mockLogger, { toolCallId }));
         import_vitest.expect.fail("Should have thrown an error");
       } catch (error) {
         (0, import_vitest.expect)(error).toBeInstanceOf(import_core2.DextoRuntimeError);
@@ -110,7 +133,7 @@ const createMockLogger = () => ({
       (0, import_vitest.expect)(content).toBe("hello world - user added this");
     });
     (0, import_vitest.it)("should detect file modification with correct error code", async () => {
-      const tool = (0, import_edit_file_tool.createEditFileTool)({ fileSystemService });
+      const tool = (0, import_edit_file_tool.createEditFileTool)(async () => fileSystemService);
       const testFile = path.join(tempDir, "test.txt");
       await fs.writeFile(testFile, "hello world");
       const toolCallId = "test-call-789";
@@ -119,10 +142,11 @@ const createMockLogger = () => ({
         old_string: "world",
         new_string: "universe"
       };
-      await tool.generatePreview(input, { toolCallId });
+      const parsedInput = tool.inputSchema.parse(input);
+      await tool.generatePreview(parsedInput, createToolContext(mockLogger, { toolCallId }));
       await fs.writeFile(testFile, "hello world modified");
       try {
-        await tool.execute(input, { toolCallId });
+        await tool.execute(parsedInput, createToolContext(mockLogger, { toolCallId }));
         import_vitest.expect.fail("Should have thrown an error");
       } catch (error) {
         (0, import_vitest.expect)(error).toBeInstanceOf(import_core2.DextoRuntimeError);
@@ -136,7 +160,7 @@ const createMockLogger = () => ({
       }
     });
     (0, import_vitest.it)("should work without toolCallId (no modification check)", async () => {
-      const tool = (0, import_edit_file_tool.createEditFileTool)({ fileSystemService });
+      const tool = (0, import_edit_file_tool.createEditFileTool)(async () => fileSystemService);
       const testFile = path.join(tempDir, "test.txt");
       await fs.writeFile(testFile, "hello world");
       const input = {
@@ -144,10 +168,11 @@ const createMockLogger = () => ({
         old_string: "world",
         new_string: "universe"
       };
-      await tool.generatePreview(input, {});
+      const parsedInput = tool.inputSchema.parse(input);
+      await tool.generatePreview(parsedInput, createToolContext(mockLogger));
       await fs.writeFile(testFile, "hello world changed");
       try {
-        await tool.execute(input, {});
+        await tool.execute(parsedInput, createToolContext(mockLogger));
       } catch (error) {
         (0, import_vitest.expect)(error).toBeInstanceOf(import_core2.DextoRuntimeError);
         (0, import_vitest.expect)(error.code).not.toBe(
@@ -156,7 +181,7 @@ const createMockLogger = () => ({
       }
     });
     (0, import_vitest.it)("should clean up hash cache after successful execution", async () => {
-      const tool = (0, import_edit_file_tool.createEditFileTool)({ fileSystemService });
+      const tool = (0, import_edit_file_tool.createEditFileTool)(async () => fileSystemService);
       const testFile = path.join(tempDir, "test.txt");
       await fs.writeFile(testFile, "hello world");
       const toolCallId = "test-call-cleanup";
@@ -165,21 +190,29 @@ const createMockLogger = () => ({
         old_string: "world",
         new_string: "universe"
       };
-      await tool.generatePreview(input, { toolCallId });
-      await tool.execute(input, { toolCallId });
+      const parsedInput = tool.inputSchema.parse(input);
+      await tool.generatePreview(parsedInput, createToolContext(mockLogger, { toolCallId }));
+      await tool.execute(parsedInput, createToolContext(mockLogger, { toolCallId }));
       const input2 = {
         file_path: testFile,
         old_string: "universe",
         new_string: "galaxy"
       };
-      await tool.generatePreview(input2, { toolCallId });
-      const result = await tool.execute(input2, { toolCallId });
+      const parsedInput2 = tool.inputSchema.parse(input2);
+      await tool.generatePreview(
+        parsedInput2,
+        createToolContext(mockLogger, { toolCallId })
+      );
+      const result = await tool.execute(
+        parsedInput2,
+        createToolContext(mockLogger, { toolCallId })
+      );
       (0, import_vitest.expect)(result.success).toBe(true);
       const content = await fs.readFile(testFile, "utf-8");
       (0, import_vitest.expect)(content).toBe("hello galaxy");
     });
     (0, import_vitest.it)("should clean up hash cache after failed execution", async () => {
-      const tool = (0, import_edit_file_tool.createEditFileTool)({ fileSystemService });
+      const tool = (0, import_edit_file_tool.createEditFileTool)(async () => fileSystemService);
       const testFile = path.join(tempDir, "test.txt");
       await fs.writeFile(testFile, "hello world");
       const toolCallId = "test-call-fail-cleanup";
@@ -188,15 +221,19 @@ const createMockLogger = () => ({
         old_string: "world",
         new_string: "universe"
       };
-      await tool.generatePreview(input, { toolCallId });
+      const parsedInput = tool.inputSchema.parse(input);
+      await tool.generatePreview(parsedInput, createToolContext(mockLogger, { toolCallId }));
       await fs.writeFile(testFile, "hello world modified");
       try {
-        await tool.execute(input, { toolCallId });
+        await tool.execute(parsedInput, createToolContext(mockLogger, { toolCallId }));
       } catch {
       }
       await fs.writeFile(testFile, "hello world");
-      await tool.generatePreview(input, { toolCallId });
-      const result = await tool.execute(input, { toolCallId });
+      await tool.generatePreview(parsedInput, createToolContext(mockLogger, { toolCallId }));
+      const result = await tool.execute(
+        parsedInput,
+        createToolContext(mockLogger, { toolCallId })
+      );
       (0, import_vitest.expect)(result.success).toBe(true);
     });
   });

package/dist/edit-file-tool.test.d.ts

@@ -1,2 +1,7 @@
-
-export {  }
+/**
+ * Edit File Tool Tests
+ *
+ * Tests for the edit_file tool including file modification detection.
+ */
+export {};
+//# sourceMappingURL=edit-file-tool.test.d.ts.map

package/dist/edit-file-tool.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edit-file-tool.test.d.ts","sourceRoot":"","sources":["../src/edit-file-tool.test.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}

package/dist/edit-file-tool.test.js

@@ -6,13 +6,25 @@ import { createEditFileTool } from "./edit-file-tool.js";
 import { FileSystemService } from "./filesystem-service.js";
 import { ToolErrorCode } from "@dexto/core";
 import { DextoRuntimeError } from "@dexto/core";
-const createMockLogger = () => ({
-  debug: vi.fn(),
-  info: vi.fn(),
-  warn: vi.fn(),
-  error: vi.fn(),
-  createChild: vi.fn().mockReturnThis()
-});
+const createMockLogger = () => {
+  const logger = {
+    debug: vi.fn(),
+    silly: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    trackException: vi.fn(),
+    createChild: vi.fn(() => logger),
+    setLevel: vi.fn(),
+    getLevel: vi.fn(() => "debug"),
+    getLogFilePath: vi.fn(() => null),
+    destroy: vi.fn(async () => void 0)
+  };
+  return logger;
+};
+function createToolContext(logger, overrides = {}) {
+  return { logger, ...overrides };
+}
 describe("edit_file tool", () => {
   let mockLogger;
   let tempDir;
@@ -44,7 +56,7 @@ describe("edit_file tool", () => {
   });
   describe("File Modification Detection", () => {
     it("should succeed when file is not modified between preview and execute", async () => {
-      const tool = createEditFileTool({ fileSystemService });
+      const tool = createEditFileTool(async () => fileSystemService);
       const testFile = path.join(tempDir, "test.txt");
       await fs.writeFile(testFile, "hello world");
       const toolCallId = "test-call-123";
@@ -53,16 +65,23 @@ describe("edit_file tool", () => {
         old_string: "world",
         new_string: "universe"
       };
-      const preview = await tool.generatePreview(input, { toolCallId });
+      const parsedInput = tool.inputSchema.parse(input);
+      const preview = await tool.generatePreview(
+        parsedInput,
+        createToolContext(mockLogger, { toolCallId })
+      );
       expect(preview).toBeDefined();
-      const result = await tool.execute(input, { toolCallId });
+      const result = await tool.execute(
+        parsedInput,
+        createToolContext(mockLogger, { toolCallId })
+      );
       expect(result.success).toBe(true);
       expect(result.path).toBe(testFile);
       const content = await fs.readFile(testFile, "utf-8");
       expect(content).toBe("hello universe");
     });
     it("should fail when file is modified between preview and execute", async () => {
-      const tool = createEditFileTool({ fileSystemService });
+      const tool = createEditFileTool(async () => fileSystemService);
       const testFile = path.join(tempDir, "test.txt");
       await fs.writeFile(testFile, "hello world");
       const toolCallId = "test-call-456";
@@ -71,11 +90,15 @@ describe("edit_file tool", () => {
         old_string: "world",
         new_string: "universe"
       };
-      const preview = await tool.generatePreview(input, { toolCallId });
+      const parsedInput = tool.inputSchema.parse(input);
+      const preview = await tool.generatePreview(
+        parsedInput,
+        createToolContext(mockLogger, { toolCallId })
+      );
       expect(preview).toBeDefined();
       await fs.writeFile(testFile, "hello world - user added this");
       try {
-        await tool.execute(input, { toolCallId });
+        await tool.execute(parsedInput, createToolContext(mockLogger, { toolCallId }));
         expect.fail("Should have thrown an error");
       } catch (error) {
         expect(error).toBeInstanceOf(DextoRuntimeError);
@@ -87,7 +110,7 @@ describe("edit_file tool", () => {
       expect(content).toBe("hello world - user added this");
     });
     it("should detect file modification with correct error code", async () => {
-      const tool = createEditFileTool({ fileSystemService });
+      const tool = createEditFileTool(async () => fileSystemService);
       const testFile = path.join(tempDir, "test.txt");
       await fs.writeFile(testFile, "hello world");
       const toolCallId = "test-call-789";
@@ -96,10 +119,11 @@ describe("edit_file tool", () => {
         old_string: "world",
         new_string: "universe"
       };
-      await tool.generatePreview(input, { toolCallId });
+      const parsedInput = tool.inputSchema.parse(input);
+      await tool.generatePreview(parsedInput, createToolContext(mockLogger, { toolCallId }));
       await fs.writeFile(testFile, "hello world modified");
       try {
-        await tool.execute(input, { toolCallId });
+        await tool.execute(parsedInput, createToolContext(mockLogger, { toolCallId }));
         expect.fail("Should have thrown an error");
       } catch (error) {
         expect(error).toBeInstanceOf(DextoRuntimeError);
@@ -113,7 +137,7 @@ describe("edit_file tool", () => {
       }
     });
     it("should work without toolCallId (no modification check)", async () => {
-      const tool = createEditFileTool({ fileSystemService });
+      const tool = createEditFileTool(async () => fileSystemService);
       const testFile = path.join(tempDir, "test.txt");
       await fs.writeFile(testFile, "hello world");
       const input = {
@@ -121,10 +145,11 @@ describe("edit_file tool", () => {
         old_string: "world",
         new_string: "universe"
       };
-      await tool.generatePreview(input, {});
+      const parsedInput = tool.inputSchema.parse(input);
+      await tool.generatePreview(parsedInput, createToolContext(mockLogger));
       await fs.writeFile(testFile, "hello world changed");
       try {
-        await tool.execute(input, {});
+        await tool.execute(parsedInput, createToolContext(mockLogger));
       } catch (error) {
         expect(error).toBeInstanceOf(DextoRuntimeError);
         expect(error.code).not.toBe(
@@ -133,7 +158,7 @@ describe("edit_file tool", () => {
       }
     });
     it("should clean up hash cache after successful execution", async () => {
-      const tool = createEditFileTool({ fileSystemService });
+      const tool = createEditFileTool(async () => fileSystemService);
       const testFile = path.join(tempDir, "test.txt");
       await fs.writeFile(testFile, "hello world");
       const toolCallId = "test-call-cleanup";
@@ -142,21 +167,29 @@ describe("edit_file tool", () => {
         old_string: "world",
         new_string: "universe"
       };
-      await tool.generatePreview(input, { toolCallId });
-      await tool.execute(input, { toolCallId });
+      const parsedInput = tool.inputSchema.parse(input);
+      await tool.generatePreview(parsedInput, createToolContext(mockLogger, { toolCallId }));
+      await tool.execute(parsedInput, createToolContext(mockLogger, { toolCallId }));
       const input2 = {
         file_path: testFile,
         old_string: "universe",
         new_string: "galaxy"
       };
-      await tool.generatePreview(input2, { toolCallId });
-      const result = await tool.execute(input2, { toolCallId });
+      const parsedInput2 = tool.inputSchema.parse(input2);
+      await tool.generatePreview(
+        parsedInput2,
+        createToolContext(mockLogger, { toolCallId })
+      );
+      const result = await tool.execute(
+        parsedInput2,
+        createToolContext(mockLogger, { toolCallId })
+      );
       expect(result.success).toBe(true);
       const content = await fs.readFile(testFile, "utf-8");
       expect(content).toBe("hello galaxy");
     });
     it("should clean up hash cache after failed execution", async () => {
-      const tool = createEditFileTool({ fileSystemService });
+      const tool = createEditFileTool(async () => fileSystemService);
       const testFile = path.join(tempDir, "test.txt");
       await fs.writeFile(testFile, "hello world");
       const toolCallId = "test-call-fail-cleanup";
@@ -165,15 +198,19 @@ describe("edit_file tool", () => {
         old_string: "world",
         new_string: "universe"
       };
-      await tool.generatePreview(input, { toolCallId });
+      const parsedInput = tool.inputSchema.parse(input);
+      await tool.generatePreview(parsedInput, createToolContext(mockLogger, { toolCallId }));
       await fs.writeFile(testFile, "hello world modified");
       try {
-        await tool.execute(input, { toolCallId });
+        await tool.execute(parsedInput, createToolContext(mockLogger, { toolCallId }));
       } catch {
       }
       await fs.writeFile(testFile, "hello world");
-      await tool.generatePreview(input, { toolCallId });
-      const result = await tool.execute(input, { toolCallId });
+      await tool.generatePreview(parsedInput, createToolContext(mockLogger, { toolCallId }));
+      const result = await tool.execute(
+        parsedInput,
+        createToolContext(mockLogger, { toolCallId })
+      );
       expect(result.success).toBe(true);
     });
   });

package/dist/error-codes.d.ts

@@ -3,7 +3,7 @@
  *
  * Standardized error codes for file system operations
  */
-declare enum FileSystemErrorCode {
+export declare enum FileSystemErrorCode {
     FILE_NOT_FOUND = "FILESYSTEM_FILE_NOT_FOUND",
     DIRECTORY_NOT_FOUND = "FILESYSTEM_DIRECTORY_NOT_FOUND",
     PERMISSION_DENIED = "FILESYSTEM_PERMISSION_DENIED",
@@ -28,5 +28,4 @@ declare enum FileSystemErrorCode {
     INVALID_CONFIG = "FILESYSTEM_INVALID_CONFIG",
     SERVICE_NOT_INITIALIZED = "FILESYSTEM_SERVICE_NOT_INITIALIZED"
 }
-
-export { FileSystemErrorCode };
+//# sourceMappingURL=error-codes.d.ts.map

package/dist/error-codes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-codes.d.ts","sourceRoot":"","sources":["../src/error-codes.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,oBAAY,mBAAmB;IAE3B,cAAc,8BAA8B;IAC5C,mBAAmB,mCAAmC;IAGtD,iBAAiB,iCAAiC;IAClD,gBAAgB,gCAAgC;IAChD,YAAY,4BAA4B;IAGxC,YAAY,4BAA4B;IACxC,uBAAuB,uCAAuC;IAC9D,sBAAsB,sCAAsC;IAC5D,gBAAgB,gCAAgC;IAGhD,cAAc,8BAA8B;IAC5C,gBAAgB,gCAAgC;IAGhD,WAAW,2BAA2B;IACtC,YAAY,4BAA4B;IACxC,aAAa,6BAA6B;IAC1C,WAAW,2BAA2B;IACtC,iBAAiB,iCAAiC;IAClD,gBAAgB,gCAAgC;IAGhD,WAAW,2BAA2B;IACtC,aAAa,6BAA6B;IAC1C,eAAe,+BAA+B;IAC9C,aAAa,6BAA6B;IAG1C,cAAc,8BAA8B;IAC5C,uBAAuB,uCAAuC;CACjE"}

package/dist/errors.d.ts

@@ -1,12 +1,10 @@
-import { DextoRuntimeError } from '@dexto/core';
-
 /**
  * FileSystem Service Errors
  *
  * Error classes for file system operations
  */
-
-interface FileSystemErrorContext {
+import { DextoRuntimeError } from '@dexto/core';
+export interface FileSystemErrorContext {
     path?: string;
     pattern?: string;
     size?: number;
@@ -17,7 +15,7 @@ interface FileSystemErrorContext {
 /**
  * Factory class for creating FileSystem-related errors
  */
-declare class FileSystemError {
+export declare class FileSystemError {
     private constructor();
     /**
      * File not found error
@@ -108,5 +106,4 @@ declare class FileSystemError {
      */
     static notInitialized(): DextoRuntimeError;
 }
-
-export { FileSystemError, type FileSystemErrorContext };
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"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"}

package/dist/file-tool-types.d.cts

@@ -1,46 +1,18 @@
+import { ToolExecutionContext } from '@dexto/core';
 import { FileSystemService } from './filesystem-service.cjs';
-import '@dexto/core';
 import './types.cjs';
 
 /**
  * File Tool Types
  *
- * Types shared between file tools for directory approval support.
+ * Types shared between file tools and factories.
  */
 
 /**
- * Callbacks for directory access approval.
- * Allows file tools to check and request approval for accessing paths
- * outside the configured working directory.
+ * Getter for a lazily-initialized {@link FileSystemService}.
+ * Tool factories construct tools before runtime services are available, so tools
+ * resolve the service on-demand using {@link ToolExecutionContext}.
  */
-interface DirectoryApprovalCallbacks {
-    /**
-     * Check if a path is within any session-approved directory.
-     * Used to determine if directory approval prompt is needed.
-     * @param filePath The file path to check (absolute or relative)
-     * @returns true if path is in a session-approved directory
-     */
-    isSessionApproved: (filePath: string) => boolean;
-    /**
-     * Add a directory to the approved list for this session.
-     * Called after user approves directory access.
-     * @param directory Absolute path to the directory to approve
-     * @param type 'session' (remembered) or 'once' (single use)
-     */
-    addApproved: (directory: string, type: 'session' | 'once') => void;
-}
-/**
- * Options for creating file tools with directory approval support
- */
-interface FileToolOptions {
-    /** FileSystemService instance for file operations */
-    fileSystemService: FileSystemService;
-    /**
-     * Optional callbacks for directory approval.
-     * If provided, file tools can request approval for accessing paths
-     * outside the configured working directory.
-     */
-    directoryApproval?: DirectoryApprovalCallbacks | undefined;
-}
+type FileSystemServiceGetter = (context: ToolExecutionContext) => Promise<FileSystemService>;
 
-export type { DirectoryApprovalCallbacks, FileToolOptions };
+export type { FileSystemServiceGetter };

package/dist/file-tool-types.d.ts

@@ -1,46 +1,14 @@
-import { FileSystemService } from './filesystem-service.js';
-import '@dexto/core';
-import './types.js';
-
 /**
  * File Tool Types
  *
- * Types shared between file tools for directory approval support.
+ * Types shared between file tools and factories.
  */
-
+import type { ToolExecutionContext } from '@dexto/core';
+import type { FileSystemService } from './filesystem-service.js';
 /**
- * Callbacks for directory access approval.
- * Allows file tools to check and request approval for accessing paths
- * outside the configured working directory.
+ * Getter for a lazily-initialized {@link FileSystemService}.
+ * Tool factories construct tools before runtime services are available, so tools
+ * resolve the service on-demand using {@link ToolExecutionContext}.
  */
-interface DirectoryApprovalCallbacks {
-    /**
-     * Check if a path is within any session-approved directory.
-     * Used to determine if directory approval prompt is needed.
-     * @param filePath The file path to check (absolute or relative)
-     * @returns true if path is in a session-approved directory
-     */
-    isSessionApproved: (filePath: string) => boolean;
-    /**
-     * Add a directory to the approved list for this session.
-     * Called after user approves directory access.
-     * @param directory Absolute path to the directory to approve
-     * @param type 'session' (remembered) or 'once' (single use)
-     */
-    addApproved: (directory: string, type: 'session' | 'once') => void;
-}
-/**
- * Options for creating file tools with directory approval support
- */
-interface FileToolOptions {
-    /** FileSystemService instance for file operations */
-    fileSystemService: FileSystemService;
-    /**
-     * Optional callbacks for directory approval.
-     * If provided, file tools can request approval for accessing paths
-     * outside the configured working directory.
-     */
-    directoryApproval?: DirectoryApprovalCallbacks | undefined;
-}
-
-export type { DirectoryApprovalCallbacks, FileToolOptions };
+export type FileSystemServiceGetter = (context: ToolExecutionContext) => Promise<FileSystemService>;
+//# sourceMappingURL=file-tool-types.d.ts.map

package/dist/file-tool-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-tool-types.d.ts","sourceRoot":"","sources":["../src/file-tool-types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AACxD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAEjE;;;;GAIG;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,OAAO,EAAE,oBAAoB,KAAK,OAAO,CAAC,iBAAiB,CAAC,CAAC"}

package/dist/filesystem-service.cjs

@@ -47,10 +47,11 @@ class FileSystemService {
   initialized = false;
   initPromise = null;
   logger;
+  directoryApprovalChecker;
   /**
    * Create a new FileSystemService with validated configuration.
    *
-   * @param config - Fully-validated configuration from provider schema.
+   * @param config - Fully-validated configuration from the factory schema.
    *                 All required fields have values, defaults already applied.
    * @param logger - Logger instance for this service
    */
@@ -124,8 +125,24 @@ class FileSystemService {
    * @param checker Function that returns true if path is in an approved directory
    */
   setDirectoryApprovalChecker(checker) {
+    this.directoryApprovalChecker = checker;
     this.pathValidator.setDirectoryApprovalChecker(checker);
   }
+  /**
+   * Update the working directory at runtime (e.g., when workspace changes).
+   * Rebuilds the PathValidator so allowed/blocked path roots are recalculated.
+   */
+  setWorkingDirectory(workingDirectory) {
+    const normalized = workingDirectory?.trim();
+    if (!normalized) return;
+    if (this.config.workingDirectory === normalized) return;
+    this.config = { ...this.config, workingDirectory: normalized };
+    this.pathValidator = new import_path_validator.PathValidator(this.config, this.logger);
+    if (this.directoryApprovalChecker) {
+      this.pathValidator.setDirectoryApprovalChecker(this.directoryApprovalChecker);
+    }
+    this.logger.info(`FileSystemService working directory set to ${normalized}`);
+  }
   /**
    * Check if a file path is within the configured allowed paths (config only).
    * This is used by file tools to determine if directory approval is needed.