@dexto/tools-filesystem 1.6.25 → 1.6.26

package/dist/tool-factory.js

@@ -28,64 +28,43 @@ const fileSystemToolsFactory = {
       backupPath: config.backupPath,
       backupRetentionDays: config.backupRetentionDays
     };
-    let fileSystemService;
     const resolveWorkingDirectory = (context) => context.workspace?.path ?? fileSystemConfig.workingDirectory ?? process.cwd();
-    const applyWorkspace = (context, service) => {
-      const workingDirectory = resolveWorkingDirectory(context);
-      service.setWorkingDirectory(workingDirectory);
-    };
-    const resolveInjectedService = (context) => {
-      const candidate = context.services?.filesystemService;
-      if (!candidate) return null;
-      if (candidate instanceof FileSystemService) return candidate;
-      const hasMethods = typeof candidate.readFile === "function" && typeof candidate.writeFile === "function" && typeof candidate.setWorkingDirectory === "function" && typeof candidate.setDirectoryApprovalChecker === "function";
-      return hasMethods ? candidate : null;
-    };
-    const getFileSystemService = async (context) => {
-      const injectedService = resolveInjectedService(context);
-      if (injectedService) {
-        const approvalManager2 = context.services?.approval;
-        if (!approvalManager2) {
-          throw ToolError.configInvalid(
-            "filesystem-tools requires ToolExecutionContext.services.approval"
-          );
-        }
-        injectedService.setDirectoryApprovalChecker(
-          (filePath) => approvalManager2.isDirectoryApproved(filePath)
-        );
-        applyWorkspace(context, injectedService);
-        return injectedService;
-      }
-      if (fileSystemService) {
-        const approvalManager2 = context.services?.approval;
-        if (!approvalManager2) {
-          throw ToolError.configInvalid(
-            "filesystem-tools requires ToolExecutionContext.services.approval"
-          );
-        }
-        fileSystemService.setDirectoryApprovalChecker(
-          (filePath) => approvalManager2.isDirectoryApproved(filePath)
-        );
-        applyWorkspace(context, fileSystemService);
-        return fileSystemService;
-      }
-      const logger = context.logger;
-      fileSystemService = new FileSystemService(fileSystemConfig, logger);
+    const createScopedFileSystemService = (context, baseConfig) => {
       const approvalManager = context.services?.approval;
       if (!approvalManager) {
         throw ToolError.configInvalid(
           "filesystem-tools requires ToolExecutionContext.services.approval"
         );
       }
-      fileSystemService.setDirectoryApprovalChecker(
-        (filePath) => approvalManager.isDirectoryApproved(filePath)
+      const service = new FileSystemService(
+        {
+          ...baseConfig,
+          workingDirectory: resolveWorkingDirectory(context)
+        },
+        context.logger
+      );
+      service.setDirectoryApprovalChecker(
+        (filePath) => approvalManager.isDirectoryApproved(filePath, context.sessionId)
+      );
+      return service;
+    };
+    const resolveInjectedServiceConfig = (context) => {
+      const candidate = context.services?.filesystemService;
+      if (!candidate) return null;
+      if (candidate instanceof FileSystemService) return candidate.getConfig();
+      const getConfig = candidate.getConfig;
+      if (typeof getConfig === "function") {
+        return getConfig.call(candidate);
+      }
+      return null;
+    };
+    const getFileSystemService = async (context) => {
+      const scopedFileSystemService = createScopedFileSystemService(
+        context,
+        resolveInjectedServiceConfig(context) ?? fileSystemConfig
       );
-      applyWorkspace(context, fileSystemService);
-      fileSystemService.initialize().catch((error) => {
-        const message = error instanceof Error ? error.message : String(error);
-        logger.error(`Failed to initialize FileSystemService: ${message}`);
-      });
-      return fileSystemService;
+      await scopedFileSystemService.initialize();
+      return scopedFileSystemService;
     };
     const toolCreators = {
       read_file: () => createReadFileTool(getFileSystemService),

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

@@ -193,6 +193,39 @@ function createToolContext(logger, overrides = {}) {
     });
   });
   (0, import_vitest.describe)("File Modification Detection - New Files", () => {
+    (0, import_vitest.it)("should expand home-directory shorthand when creating a file", async () => {
+      const homeTempDir = await fs.mkdtemp(
+        path.join(os.homedir(), ".dexto-write-home-test-")
+      );
+      const homeRelativeDir = `~/${path.basename(homeTempDir)}`;
+      const fileSystemServiceForHome = new import_filesystem_service.FileSystemService(
+        {
+          allowedPaths: [homeTempDir],
+          blockedPaths: [],
+          blockedExtensions: [],
+          maxFileSize: 10 * 1024 * 1024,
+          workingDirectory: tempDir,
+          enableBackups: false,
+          backupRetentionDays: 7
+        },
+        mockLogger
+      );
+      await fileSystemServiceForHome.initialize();
+      const tool = (0, import_write_file_tool.createWriteFileTool)(async () => fileSystemServiceForHome);
+      try {
+        const parsedInput = tool.inputSchema.parse({
+          file_path: `${homeRelativeDir}/nested/new-file.txt`,
+          content: "brand new content",
+          create_dirs: true
+        });
+        const result = await tool.execute(parsedInput, createToolContext(mockLogger));
+        (0, import_vitest.expect)(result.success).toBe(true);
+        (0, import_vitest.expect)(result.path).toBe(path.join(homeTempDir, "nested", "new-file.txt"));
+        (0, import_vitest.expect)(await fs.readFile(result.path, "utf-8")).toBe("brand new content");
+      } finally {
+        await fs.rm(homeTempDir, { recursive: true, force: true });
+      }
+    });
     (0, import_vitest.it)("should succeed when creating new file that still does not exist", async () => {
       const tool = (0, import_write_file_tool.createWriteFileTool)(async () => fileSystemService);
       const testFile = path.join(tempDir, "new-file.txt");

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

@@ -170,6 +170,39 @@ describe("write_file tool", () => {
     });
   });
   describe("File Modification Detection - New Files", () => {
+    it("should expand home-directory shorthand when creating a file", async () => {
+      const homeTempDir = await fs.mkdtemp(
+        path.join(os.homedir(), ".dexto-write-home-test-")
+      );
+      const homeRelativeDir = `~/${path.basename(homeTempDir)}`;
+      const fileSystemServiceForHome = new FileSystemService(
+        {
+          allowedPaths: [homeTempDir],
+          blockedPaths: [],
+          blockedExtensions: [],
+          maxFileSize: 10 * 1024 * 1024,
+          workingDirectory: tempDir,
+          enableBackups: false,
+          backupRetentionDays: 7
+        },
+        mockLogger
+      );
+      await fileSystemServiceForHome.initialize();
+      const tool = createWriteFileTool(async () => fileSystemServiceForHome);
+      try {
+        const parsedInput = tool.inputSchema.parse({
+          file_path: `${homeRelativeDir}/nested/new-file.txt`,
+          content: "brand new content",
+          create_dirs: true
+        });
+        const result = await tool.execute(parsedInput, createToolContext(mockLogger));
+        expect(result.success).toBe(true);
+        expect(result.path).toBe(path.join(homeTempDir, "nested", "new-file.txt"));
+        expect(await fs.readFile(result.path, "utf-8")).toBe("brand new content");
+      } finally {
+        await fs.rm(homeTempDir, { recursive: true, force: true });
+      }
+    });
     it("should succeed when creating new file that still does not exist", async () => {
       const tool = createWriteFileTool(async () => fileSystemService);
       const testFile = path.join(tempDir, "new-file.txt");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dexto/tools-filesystem",
-  "version": "1.6.25",
+  "version": "1.6.26",
   "description": "FileSystem tools factory for Dexto agents",
   "type": "module",
   "main": "./dist/index.js",
@@ -22,8 +22,8 @@
     "glob": "^12.0.0",
     "safe-regex": "^2.1.1",
     "zod": "^3.25.0",
-    "@dexto/agent-config": "1.6.25",
-    "@dexto/core": "1.6.25"
+    "@dexto/agent-config": "1.6.26",
+    "@dexto/core": "1.6.26"
   },
   "devDependencies": {
     "@types/diff": "^5.2.3",