@dexto/tools-filesystem 1.5.0

package/dist/path-validator.test.cjs

@@ -0,0 +1,444 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_path_validator = require("./path-validator.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)("PathValidator", () => {
+  let mockLogger;
+  (0, import_vitest.beforeEach)(() => {
+    mockLogger = createMockLogger();
+    import_vitest.vi.clearAllMocks();
+  });
+  (0, import_vitest.describe)("validatePath", () => {
+    (0, import_vitest.describe)("Empty and Invalid Paths", () => {
+      (0, import_vitest.it)("should reject empty path", () => {
+        const validator = new import_path_validator.PathValidator(
+          {
+            allowedPaths: ["/home/user/project"],
+            blockedPaths: [],
+            blockedExtensions: [],
+            maxFileSize: 10 * 1024 * 1024,
+            enableBackups: false,
+            backupRetentionDays: 7,
+            workingDirectory: "/home/user/project"
+          },
+          mockLogger
+        );
+        const result = validator.validatePath("");
+        (0, import_vitest.expect)(result.isValid).toBe(false);
+        (0, import_vitest.expect)(result.error).toBe("Path cannot be empty");
+      });
+      (0, import_vitest.it)("should reject whitespace-only path", () => {
+        const validator = new import_path_validator.PathValidator(
+          {
+            allowedPaths: ["/home/user/project"],
+            blockedPaths: [],
+            blockedExtensions: [],
+            maxFileSize: 10 * 1024 * 1024,
+            enableBackups: false,
+            backupRetentionDays: 7,
+            workingDirectory: "/home/user/project"
+          },
+          mockLogger
+        );
+        const result = validator.validatePath("   ");
+        (0, import_vitest.expect)(result.isValid).toBe(false);
+        (0, import_vitest.expect)(result.error).toBe("Path cannot be empty");
+      });
+    });
+    (0, import_vitest.describe)("Allowed Paths", () => {
+      (0, import_vitest.it)("should allow paths within allowed directories", () => {
+        const validator = new import_path_validator.PathValidator(
+          {
+            allowedPaths: ["/home/user/project"],
+            blockedPaths: [],
+            blockedExtensions: [],
+            maxFileSize: 10 * 1024 * 1024,
+            enableBackups: false,
+            backupRetentionDays: 7,
+            workingDirectory: "/home/user/project"
+          },
+          mockLogger
+        );
+        const result = validator.validatePath("/home/user/project/src/file.ts");
+        (0, import_vitest.expect)(result.isValid).toBe(true);
+        (0, import_vitest.expect)(result.normalizedPath).toBeDefined();
+      });
+      (0, import_vitest.it)("should allow relative paths within working directory", () => {
+        const validator = new import_path_validator.PathValidator(
+          {
+            allowedPaths: ["/home/user/project"],
+            blockedPaths: [],
+            blockedExtensions: [],
+            maxFileSize: 10 * 1024 * 1024,
+            enableBackups: false,
+            backupRetentionDays: 7,
+            workingDirectory: "/home/user/project"
+          },
+          mockLogger
+        );
+        const result = validator.validatePath("src/file.ts");
+        (0, import_vitest.expect)(result.isValid).toBe(true);
+      });
+      (0, import_vitest.it)("should reject paths outside allowed directories", () => {
+        const validator = new import_path_validator.PathValidator(
+          {
+            allowedPaths: ["/home/user/project"],
+            blockedPaths: [],
+            blockedExtensions: [],
+            maxFileSize: 10 * 1024 * 1024,
+            enableBackups: false,
+            backupRetentionDays: 7,
+            workingDirectory: "/home/user/project"
+          },
+          mockLogger
+        );
+        const result = validator.validatePath("/external/project/file.ts");
+        (0, import_vitest.expect)(result.isValid).toBe(false);
+        (0, import_vitest.expect)(result.error).toContain("not within allowed paths");
+      });
+      (0, import_vitest.it)("should allow all paths when allowedPaths is empty", () => {
+        const validator = new import_path_validator.PathValidator(
+          {
+            allowedPaths: [],
+            blockedPaths: [],
+            blockedExtensions: [],
+            maxFileSize: 10 * 1024 * 1024,
+            enableBackups: false,
+            backupRetentionDays: 7,
+            workingDirectory: "/home/user/project"
+          },
+          mockLogger
+        );
+        const result = validator.validatePath("/anywhere/file.ts");
+        (0, import_vitest.expect)(result.isValid).toBe(true);
+      });
+    });
+    (0, import_vitest.describe)("Path Traversal Detection", () => {
+      (0, import_vitest.it)("should reject path traversal attempts", () => {
+        const validator = new import_path_validator.PathValidator(
+          {
+            allowedPaths: ["/home/user/project"],
+            blockedPaths: [],
+            blockedExtensions: [],
+            maxFileSize: 10 * 1024 * 1024,
+            enableBackups: false,
+            backupRetentionDays: 7,
+            workingDirectory: "/home/user/project"
+          },
+          mockLogger
+        );
+        const result = validator.validatePath("/home/user/project/../../../etc/passwd");
+        (0, import_vitest.expect)(result.isValid).toBe(false);
+        (0, import_vitest.expect)(result.error).toBe("Path traversal detected");
+      });
+    });
+    (0, import_vitest.describe)("Blocked Paths", () => {
+      (0, import_vitest.it)("should reject paths in blocked directories", () => {
+        const validator = new import_path_validator.PathValidator(
+          {
+            allowedPaths: ["/home/user/project"],
+            blockedPaths: [".git", "node_modules"],
+            blockedExtensions: [],
+            maxFileSize: 10 * 1024 * 1024,
+            enableBackups: false,
+            backupRetentionDays: 7,
+            workingDirectory: "/home/user/project"
+          },
+          mockLogger
+        );
+        const result = validator.validatePath("/home/user/project/.git/config");
+        (0, import_vitest.expect)(result.isValid).toBe(false);
+        (0, import_vitest.expect)(result.error).toContain("blocked");
+      });
+      (0, import_vitest.it)("should reject paths in node_modules", () => {
+        const validator = new import_path_validator.PathValidator(
+          {
+            allowedPaths: ["/home/user/project"],
+            blockedPaths: ["node_modules"],
+            blockedExtensions: [],
+            maxFileSize: 10 * 1024 * 1024,
+            enableBackups: false,
+            backupRetentionDays: 7,
+            workingDirectory: "/home/user/project"
+          },
+          mockLogger
+        );
+        const result = validator.validatePath(
+          "/home/user/project/node_modules/lodash/index.js"
+        );
+        (0, import_vitest.expect)(result.isValid).toBe(false);
+        (0, import_vitest.expect)(result.error).toContain("blocked");
+      });
+    });
+    (0, import_vitest.describe)("Blocked Extensions", () => {
+      (0, import_vitest.it)("should reject files with blocked extensions", () => {
+        const validator = new import_path_validator.PathValidator(
+          {
+            allowedPaths: ["/home/user/project"],
+            blockedPaths: [],
+            blockedExtensions: [".exe", ".dll"],
+            maxFileSize: 10 * 1024 * 1024,
+            enableBackups: false,
+            backupRetentionDays: 7,
+            workingDirectory: "/home/user/project"
+          },
+          mockLogger
+        );
+        const result = validator.validatePath("/home/user/project/malware.exe");
+        (0, import_vitest.expect)(result.isValid).toBe(false);
+        (0, import_vitest.expect)(result.error).toContain(".exe is not allowed");
+      });
+      (0, import_vitest.it)("should handle extensions without leading dot", () => {
+        const validator = new import_path_validator.PathValidator(
+          {
+            allowedPaths: ["/home/user/project"],
+            blockedPaths: [],
+            blockedExtensions: ["exe", "dll"],
+            // No leading dot
+            maxFileSize: 10 * 1024 * 1024,
+            enableBackups: false,
+            backupRetentionDays: 7,
+            workingDirectory: "/home/user/project"
+          },
+          mockLogger
+        );
+        const result = validator.validatePath("/home/user/project/file.exe");
+        (0, import_vitest.expect)(result.isValid).toBe(false);
+      });
+      (0, import_vitest.it)("should be case-insensitive for extensions", () => {
+        const validator = new import_path_validator.PathValidator(
+          {
+            allowedPaths: ["/home/user/project"],
+            blockedPaths: [],
+            blockedExtensions: [".exe"],
+            maxFileSize: 10 * 1024 * 1024,
+            enableBackups: false,
+            backupRetentionDays: 7,
+            workingDirectory: "/home/user/project"
+          },
+          mockLogger
+        );
+        const result = validator.validatePath("/home/user/project/file.EXE");
+        (0, import_vitest.expect)(result.isValid).toBe(false);
+      });
+    });
+    (0, import_vitest.describe)("Directory Approval Checker Integration", () => {
+      (0, import_vitest.it)("should consult approval checker for external paths", () => {
+        const validator = new import_path_validator.PathValidator(
+          {
+            allowedPaths: ["/home/user/project"],
+            blockedPaths: [],
+            blockedExtensions: [],
+            maxFileSize: 10 * 1024 * 1024,
+            enableBackups: false,
+            backupRetentionDays: 7,
+            workingDirectory: "/home/user/project"
+          },
+          mockLogger
+        );
+        let result = validator.validatePath("/external/project/file.ts");
+        (0, import_vitest.expect)(result.isValid).toBe(false);
+        const approvalChecker = (filePath) => {
+          return filePath.startsWith("/external/project");
+        };
+        validator.setDirectoryApprovalChecker(approvalChecker);
+        result = validator.validatePath("/external/project/file.ts");
+        (0, import_vitest.expect)(result.isValid).toBe(true);
+      });
+      (0, import_vitest.it)("should not use approval checker for config-allowed paths", () => {
+        const approvalChecker = import_vitest.vi.fn().mockReturnValue(false);
+        const validator = new import_path_validator.PathValidator(
+          {
+            allowedPaths: ["/home/user/project"],
+            blockedPaths: [],
+            blockedExtensions: [],
+            maxFileSize: 10 * 1024 * 1024,
+            enableBackups: false,
+            backupRetentionDays: 7,
+            workingDirectory: "/home/user/project"
+          },
+          mockLogger
+        );
+        validator.setDirectoryApprovalChecker(approvalChecker);
+        const result = validator.validatePath("/home/user/project/src/file.ts");
+        (0, import_vitest.expect)(result.isValid).toBe(true);
+        (0, import_vitest.expect)(approvalChecker).not.toHaveBeenCalled();
+      });
+    });
+  });
+  (0, import_vitest.describe)("isPathWithinAllowed", () => {
+    (0, import_vitest.it)("should return true for paths within config-allowed directories", () => {
+      const validator = new import_path_validator.PathValidator(
+        {
+          allowedPaths: ["/home/user/project"],
+          blockedPaths: [],
+          blockedExtensions: [],
+          maxFileSize: 10 * 1024 * 1024,
+          enableBackups: false,
+          backupRetentionDays: 7,
+          workingDirectory: "/home/user/project"
+        },
+        mockLogger
+      );
+      (0, import_vitest.expect)(validator.isPathWithinAllowed("/home/user/project/src/file.ts")).toBe(true);
+      (0, import_vitest.expect)(validator.isPathWithinAllowed("/home/user/project/deep/nested/file.ts")).toBe(
+        true
+      );
+    });
+    (0, import_vitest.it)("should return false for paths outside config-allowed directories", () => {
+      const validator = new import_path_validator.PathValidator(
+        {
+          allowedPaths: ["/home/user/project"],
+          blockedPaths: [],
+          blockedExtensions: [],
+          maxFileSize: 10 * 1024 * 1024,
+          enableBackups: false,
+          backupRetentionDays: 7,
+          workingDirectory: "/home/user/project"
+        },
+        mockLogger
+      );
+      (0, import_vitest.expect)(validator.isPathWithinAllowed("/external/project/file.ts")).toBe(false);
+      (0, import_vitest.expect)(validator.isPathWithinAllowed("/home/user/other/file.ts")).toBe(false);
+    });
+    (0, import_vitest.it)("should NOT consult approval checker (used for prompting decisions)", () => {
+      const approvalChecker = import_vitest.vi.fn().mockReturnValue(true);
+      const validator = new import_path_validator.PathValidator(
+        {
+          allowedPaths: ["/home/user/project"],
+          blockedPaths: [],
+          blockedExtensions: [],
+          maxFileSize: 10 * 1024 * 1024,
+          enableBackups: false,
+          backupRetentionDays: 7,
+          workingDirectory: "/home/user/project"
+        },
+        mockLogger
+      );
+      validator.setDirectoryApprovalChecker(approvalChecker);
+      (0, import_vitest.expect)(validator.isPathWithinAllowed("/external/project/file.ts")).toBe(false);
+      (0, import_vitest.expect)(approvalChecker).not.toHaveBeenCalled();
+    });
+    (0, import_vitest.it)("should return false for empty path", () => {
+      const validator = new import_path_validator.PathValidator(
+        {
+          allowedPaths: ["/home/user/project"],
+          blockedPaths: [],
+          blockedExtensions: [],
+          maxFileSize: 10 * 1024 * 1024,
+          enableBackups: false,
+          backupRetentionDays: 7,
+          workingDirectory: "/home/user/project"
+        },
+        mockLogger
+      );
+      (0, import_vitest.expect)(validator.isPathWithinAllowed("")).toBe(false);
+      (0, import_vitest.expect)(validator.isPathWithinAllowed("   ")).toBe(false);
+    });
+    (0, import_vitest.it)("should return true when allowedPaths is empty (all paths allowed)", () => {
+      const validator = new import_path_validator.PathValidator(
+        {
+          allowedPaths: [],
+          blockedPaths: [],
+          blockedExtensions: [],
+          maxFileSize: 10 * 1024 * 1024,
+          enableBackups: false,
+          backupRetentionDays: 7,
+          workingDirectory: "/home/user/project"
+        },
+        mockLogger
+      );
+      (0, import_vitest.expect)(validator.isPathWithinAllowed("/anywhere/file.ts")).toBe(true);
+    });
+  });
+  (0, import_vitest.describe)("Path Containment (Parent Directory Coverage)", () => {
+    (0, import_vitest.it)("should recognize that approving parent covers child paths", () => {
+      const validator = new import_path_validator.PathValidator(
+        {
+          allowedPaths: ["/external/sub"],
+          blockedPaths: [],
+          blockedExtensions: [],
+          maxFileSize: 10 * 1024 * 1024,
+          enableBackups: false,
+          backupRetentionDays: 7,
+          workingDirectory: "/home/user/project"
+        },
+        mockLogger
+      );
+      (0, import_vitest.expect)(validator.isPathWithinAllowed("/external/sub/deep/nested/file.ts")).toBe(true);
+    });
+    (0, import_vitest.it)("should not allow sibling directories", () => {
+      const validator = new import_path_validator.PathValidator(
+        {
+          allowedPaths: ["/external/sub"],
+          blockedPaths: [],
+          blockedExtensions: [],
+          maxFileSize: 10 * 1024 * 1024,
+          enableBackups: false,
+          backupRetentionDays: 7,
+          workingDirectory: "/home/user/project"
+        },
+        mockLogger
+      );
+      (0, import_vitest.expect)(validator.isPathWithinAllowed("/external/other/file.ts")).toBe(false);
+    });
+    (0, import_vitest.it)("should not allow parent directories when child is approved", () => {
+      const validator = new import_path_validator.PathValidator(
+        {
+          allowedPaths: ["/external/sub/deep"],
+          blockedPaths: [],
+          blockedExtensions: [],
+          maxFileSize: 10 * 1024 * 1024,
+          enableBackups: false,
+          backupRetentionDays: 7,
+          workingDirectory: "/home/user/project"
+        },
+        mockLogger
+      );
+      (0, import_vitest.expect)(validator.isPathWithinAllowed("/external/sub/file.ts")).toBe(false);
+    });
+  });
+  (0, import_vitest.describe)("getAllowedPaths and getBlockedPaths", () => {
+    (0, import_vitest.it)("should return normalized allowed paths", () => {
+      const validator = new import_path_validator.PathValidator(
+        {
+          allowedPaths: [".", "./src"],
+          blockedPaths: [],
+          blockedExtensions: [],
+          maxFileSize: 10 * 1024 * 1024,
+          enableBackups: false,
+          backupRetentionDays: 7,
+          workingDirectory: "/home/user/project"
+        },
+        mockLogger
+      );
+      const allowedPaths = validator.getAllowedPaths();
+      (0, import_vitest.expect)(allowedPaths).toHaveLength(2);
+      (0, import_vitest.expect)(allowedPaths[0]).toBe("/home/user/project");
+      (0, import_vitest.expect)(allowedPaths[1]).toBe("/home/user/project/src");
+    });
+    (0, import_vitest.it)("should return blocked paths", () => {
+      const validator = new import_path_validator.PathValidator(
+        {
+          allowedPaths: ["/home/user/project"],
+          blockedPaths: [".git", "node_modules"],
+          blockedExtensions: [],
+          maxFileSize: 10 * 1024 * 1024,
+          enableBackups: false,
+          backupRetentionDays: 7,
+          workingDirectory: "/home/user/project"
+        },
+        mockLogger
+      );
+      const blockedPaths = validator.getBlockedPaths();
+      (0, import_vitest.expect)(blockedPaths).toContain(".git");
+      (0, import_vitest.expect)(blockedPaths).toContain("node_modules");
+    });
+  });
+});

package/dist/path-validator.test.d.cts

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

package/dist/path-validator.test.d.ts

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