@dexto/tools-filesystem 1.6.25 → 1.6.27

package/dist/grep-content-tool.test.js

@@ -0,0 +1,92 @@
+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";
+import { createGrepContentTool } from "./grep-content-tool.js";
+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),
+    createFileOnlyChild: 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) {
+  return { logger };
+}
+describe("grep_content tool", () => {
+  let mockLogger;
+  let tempDir;
+  let fileSystemService;
+  beforeEach(async () => {
+    mockLogger = createMockLogger();
+    const rawTempDir = await fs.mkdtemp(path.join(os.tmpdir(), "dexto-grep-test-"));
+    tempDir = await fs.realpath(rawTempDir);
+    fileSystemService = new FileSystemService(
+      {
+        allowedPaths: [tempDir],
+        blockedPaths: [],
+        blockedExtensions: [],
+        maxFileSize: 10 * 1024 * 1024,
+        workingDirectory: tempDir,
+        enableBackups: false,
+        backupRetentionDays: 7
+      },
+      mockLogger
+    );
+    await fileSystemService.initialize();
+  });
+  afterEach(async () => {
+    vi.restoreAllMocks();
+    try {
+      await fs.rm(tempDir, { recursive: true, force: true });
+    } catch {
+    }
+  });
+  it("expands home-directory shorthand for search paths", async () => {
+    const homeTempDir = await fs.mkdtemp(path.join(os.homedir(), ".dexto-grep-home-test-"));
+    const fileSystemServiceForHome = new FileSystemService(
+      {
+        allowedPaths: [homeTempDir],
+        blockedPaths: [],
+        blockedExtensions: [],
+        maxFileSize: 10 * 1024 * 1024,
+        workingDirectory: tempDir,
+        enableBackups: false,
+        backupRetentionDays: 7
+      },
+      mockLogger
+    );
+    await fileSystemServiceForHome.initialize();
+    try {
+      const filePath = path.join(homeTempDir, "notes.txt");
+      await fs.writeFile(filePath, "alpha\nneedle\nomega\n");
+      const tool = createGrepContentTool(async () => fileSystemServiceForHome);
+      const parsedInput = tool.inputSchema.parse({
+        pattern: "needle",
+        path: `~/${path.basename(homeTempDir)}`
+      });
+      const result = await tool.execute(parsedInput, createToolContext(mockLogger));
+      expect(result.files_searched).toBe(1);
+      expect(result.matches).toEqual([
+        {
+          file: filePath,
+          line_number: 2,
+          line: "needle"
+        }
+      ]);
+    } finally {
+      await fs.rm(homeTempDir, { recursive: true, force: true });
+    }
+  });
+});

package/dist/path-utils.cjs

@@ -0,0 +1,55 @@
+"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)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var path_utils_exports = {};
+__export(path_utils_exports, {
+  expandHomeShorthand: () => expandHomeShorthand,
+  resolveUserPath: () => resolveUserPath
+});
+module.exports = __toCommonJS(path_utils_exports);
+var os = __toESM(require("node:os"), 1);
+var path = __toESM(require("node:path"), 1);
+function expandHomeShorthand(inputPath) {
+  if (!/^~(?=$|[\\/])/.test(inputPath)) {
+    return inputPath;
+  }
+  if (inputPath === "~") {
+    return os.homedir();
+  }
+  return path.join(os.homedir(), inputPath.slice(2));
+}
+function resolveUserPath(workingDirectory, inputPath) {
+  const resolvedWorkingDirectory = path.resolve(expandHomeShorthand(workingDirectory));
+  const expandedPath = expandHomeShorthand(inputPath);
+  return path.isAbsolute(expandedPath) ? path.resolve(expandedPath) : path.resolve(resolvedWorkingDirectory, expandedPath);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  expandHomeShorthand,
+  resolveUserPath
+});

package/dist/path-utils.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Expand a leading home-directory shorthand (`~`) into an absolute path.
+ * Leaves other path shapes untouched, including `~user/...`.
+ */
+export declare function expandHomeShorthand(inputPath: string): string;
+/**
+ * Resolve a user-supplied path against a working directory after expanding
+ * supported home-directory shorthand.
+ */
+export declare function resolveUserPath(workingDirectory: string, inputPath: string): string;
+//# sourceMappingURL=path-utils.d.ts.map

package/dist/path-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-utils.d.ts","sourceRoot":"","sources":["../src/path-utils.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAU7D;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,gBAAgB,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAMnF"}

package/dist/path-utils.js

@@ -0,0 +1,20 @@
+import * as os from "node:os";
+import * as path from "node:path";
+function expandHomeShorthand(inputPath) {
+  if (!/^~(?=$|[\\/])/.test(inputPath)) {
+    return inputPath;
+  }
+  if (inputPath === "~") {
+    return os.homedir();
+  }
+  return path.join(os.homedir(), inputPath.slice(2));
+}
+function resolveUserPath(workingDirectory, inputPath) {
+  const resolvedWorkingDirectory = path.resolve(expandHomeShorthand(workingDirectory));
+  const expandedPath = expandHomeShorthand(inputPath);
+  return path.isAbsolute(expandedPath) ? path.resolve(expandedPath) : path.resolve(resolvedWorkingDirectory, expandedPath);
+}
+export {
+  expandHomeShorthand,
+  resolveUserPath
+};

package/dist/path-utils.test.cjs

@@ -0,0 +1,52 @@
+"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 os = __toESM(require("node:os"), 1);
+var path = __toESM(require("node:path"), 1);
+var import_path_utils = require("./path-utils.js");
+(0, import_vitest.describe)("path-utils", () => {
+  (0, import_vitest.it)("expands bare home shorthand", () => {
+    (0, import_vitest.expect)((0, import_path_utils.expandHomeShorthand)("~")).toBe(os.homedir());
+  });
+  (0, import_vitest.it)("expands home shorthand with nested path segments", () => {
+    (0, import_vitest.expect)((0, import_path_utils.expandHomeShorthand)("~/Projects/test.md")).toBe(
+      path.join(os.homedir(), "Projects", "test.md")
+    );
+    (0, import_vitest.expect)((0, import_path_utils.expandHomeShorthand)("~\\Projects\\test.md")).toBe(
+      path.join(os.homedir(), "Projects\\test.md")
+    );
+  });
+  (0, import_vitest.it)("does not expand unsupported user-home syntax", () => {
+    (0, import_vitest.expect)((0, import_path_utils.expandHomeShorthand)("~other-user/file.txt")).toBe("~other-user/file.txt");
+  });
+  (0, import_vitest.it)("resolves home shorthand before relative resolution", () => {
+    (0, import_vitest.expect)((0, import_path_utils.resolveUserPath)("/workspace", "~/Projects/test.md")).toBe(
+      path.join(os.homedir(), "Projects", "test.md")
+    );
+    (0, import_vitest.expect)((0, import_path_utils.resolveUserPath)("/workspace", "notes/today.md")).toBe("/workspace/notes/today.md");
+    (0, import_vitest.expect)((0, import_path_utils.resolveUserPath)("~", "notes/today.md")).toBe(
+      path.join(os.homedir(), "notes/today.md")
+    );
+  });
+});

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=path-utils.test.d.ts.map

package/dist/path-utils.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-utils.test.d.ts","sourceRoot":"","sources":["../src/path-utils.test.ts"],"names":[],"mappings":""}

package/dist/path-utils.test.js

@@ -0,0 +1,29 @@
+import { describe, it, expect } from "vitest";
+import * as os from "node:os";
+import * as path from "node:path";
+import { expandHomeShorthand, resolveUserPath } from "./path-utils.js";
+describe("path-utils", () => {
+  it("expands bare home shorthand", () => {
+    expect(expandHomeShorthand("~")).toBe(os.homedir());
+  });
+  it("expands home shorthand with nested path segments", () => {
+    expect(expandHomeShorthand("~/Projects/test.md")).toBe(
+      path.join(os.homedir(), "Projects", "test.md")
+    );
+    expect(expandHomeShorthand("~\\Projects\\test.md")).toBe(
+      path.join(os.homedir(), "Projects\\test.md")
+    );
+  });
+  it("does not expand unsupported user-home syntax", () => {
+    expect(expandHomeShorthand("~other-user/file.txt")).toBe("~other-user/file.txt");
+  });
+  it("resolves home shorthand before relative resolution", () => {
+    expect(resolveUserPath("/workspace", "~/Projects/test.md")).toBe(
+      path.join(os.homedir(), "Projects", "test.md")
+    );
+    expect(resolveUserPath("/workspace", "notes/today.md")).toBe("/workspace/notes/today.md");
+    expect(resolveUserPath("~", "notes/today.md")).toBe(
+      path.join(os.homedir(), "notes/today.md")
+    );
+  });
+});

package/dist/path-validator.cjs

@@ -33,6 +33,7 @@ __export(path_validator_exports, {
 module.exports = __toCommonJS(path_validator_exports);
 var path = __toESM(require("node:path"), 1);
 var fs = __toESM(require("node:fs/promises"), 1);
+var import_path_utils = require("./path-utils.js");
 class PathValidator {
   config;
   normalizedAllowedPaths;
@@ -43,9 +44,13 @@ class PathValidator {
   constructor(config, logger) {
     this.config = config;
     this.logger = logger;
-    const workingDir = config.workingDirectory || process.cwd();
-    this.normalizedAllowedPaths = config.allowedPaths.map((p) => path.resolve(workingDir, p));
-    this.normalizedBlockedPaths = config.blockedPaths.map((p) => path.normalize(p));
+    const workingDir = (0, import_path_utils.resolveUserPath)(process.cwd(), config.workingDirectory || process.cwd());
+    this.normalizedAllowedPaths = config.allowedPaths.map(
+      (p) => (0, import_path_utils.resolveUserPath)(workingDir, p)
+    );
+    this.normalizedBlockedPaths = config.blockedPaths.map(
+      (p) => path.normalize((0, import_path_utils.expandHomeShorthand)(p))
+    );
     this.normalizedBlockedExtensions = (config.blockedExtensions || []).map((ext) => {
       const e = ext.startsWith(".") ? ext : `.${ext}`;
       return e.toLowerCase();
@@ -92,11 +97,14 @@ class PathValidator {
         error: "Path cannot be empty"
       };
     }
-    const workingDir = this.config.workingDirectory || process.cwd();
+    const workingDir = (0, import_path_utils.resolveUserPath)(
+      process.cwd(),
+      this.config.workingDirectory || process.cwd()
+    );
     let resolvedPath;
     let normalizedPath;
     try {
-      resolvedPath = path.isAbsolute(filePath) ? path.resolve(filePath) : path.resolve(workingDir, filePath);
+      resolvedPath = (0, import_path_utils.resolveUserPath)(workingDir, filePath);
       normalizedPath = resolvedPath;
       try {
         normalizedPath = await fs.realpath(normalizedPath);
@@ -150,7 +158,10 @@ class PathValidator {
    */
   hasPathTraversal(originalPath, normalizedPath) {
     if (originalPath.includes("../") || originalPath.includes("..\\")) {
-      const workingDir = this.config.workingDirectory || process.cwd();
+      const workingDir = (0, import_path_utils.resolveUserPath)(
+        process.cwd(),
+        this.config.workingDirectory || process.cwd()
+      );
       const relative = path.relative(workingDir, normalizedPath);
       if (relative.startsWith("..")) {
         return true;
@@ -170,7 +181,7 @@ class PathValidator {
    * Check if path matches blocked patterns (blacklist check)
    */
   isPathBlocked(normalizedPath) {
-    const roots = this.normalizedAllowedPaths.length > 0 ? this.normalizedAllowedPaths : [this.config.workingDirectory || process.cwd()];
+    const roots = this.normalizedAllowedPaths.length > 0 ? this.normalizedAllowedPaths : [(0, import_path_utils.resolveUserPath)(process.cwd(), this.config.workingDirectory || process.cwd())];
     for (const blocked of this.normalizedBlockedPaths) {
       for (const root of roots) {
         const blockedFull = path.isAbsolute(blocked) ? path.normalize(blocked) : path.resolve(root, blocked);
@@ -222,10 +233,13 @@ class PathValidator {
     if (!filePath || filePath.trim() === "") {
       return false;
     }
-    const workingDir = this.config.workingDirectory || process.cwd();
+    const workingDir = (0, import_path_utils.resolveUserPath)(
+      process.cwd(),
+      this.config.workingDirectory || process.cwd()
+    );
     let normalizedPath;
     try {
-      normalizedPath = path.isAbsolute(filePath) ? path.resolve(filePath) : path.resolve(workingDir, filePath);
+      normalizedPath = (0, import_path_utils.resolveUserPath)(workingDir, filePath);
       try {
         normalizedPath = await fs.realpath(normalizedPath);
       } catch {

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

@@ -1 +1 @@
-{"version":3,"file":"path-validator.d.ts","sourceRoot":"","sources":["../src/path-validator.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC9D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1C;;;GAGG;AACH,MAAM,MAAM,wBAAwB,GAAG,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC;AAErE;;;;;;;;;;;;GAYG;AACH,qBAAa,aAAa;IACtB,OAAO,CAAC,MAAM,CAAmB;IACjC,OAAO,CAAC,sBAAsB,CAAW;IACzC,OAAO,CAAC,sBAAsB,CAAW;IACzC,OAAO,CAAC,2BAA2B,CAAW;IAC9C,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,wBAAwB,CAAuC;gBAE3D,MAAM,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM;IAsBpD;;;;;OAKG;IACH,2BAA2B,CAAC,OAAO,EAAE,wBAAwB,GAAG,IAAI;IAKpE;;OAEG;IACG,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC;IAI7D;;;;;;;;;;;OAWG;IACG,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC;YAIzD,oBAAoB;IAyFlC;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAaxB;;;;OAIG;IACH,OAAO,CAAC,aAAa;IAIrB;;OAEG;IACH,OAAO,CAAC,aAAa;IAyBrB;;;OAGG;IACH,kBAAkB,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO;IAInD;;;OAGG;IACH,OAAO,CAAC,iBAAiB;IAyBzB;;;;;;;;;OASG;IACG,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IA8B7D;;;OAGG;IACH,OAAO,CAAC,sBAAsB;IAY9B;;OAEG;IACH,eAAe,IAAI,MAAM,EAAE;IAI3B;;OAEG;IACH,eAAe,IAAI,MAAM,EAAE;CAG9B"}
+{"version":3,"file":"path-validator.d.ts","sourceRoot":"","sources":["../src/path-validator.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC9D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAG1C;;;GAGG;AACH,MAAM,MAAM,wBAAwB,GAAG,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC;AAErE;;;;;;;;;;;;GAYG;AACH,qBAAa,aAAa;IACtB,OAAO,CAAC,MAAM,CAAmB;IACjC,OAAO,CAAC,sBAAsB,CAAW;IACzC,OAAO,CAAC,sBAAsB,CAAW;IACzC,OAAO,CAAC,2BAA2B,CAAW;IAC9C,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,wBAAwB,CAAuC;gBAE3D,MAAM,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM;IA0BpD;;;;;OAKG;IACH,2BAA2B,CAAC,OAAO,EAAE,wBAAwB,GAAG,IAAI;IAKpE;;OAEG;IACG,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC;IAI7D;;;;;;;;;;;OAWG;IACG,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC;YAIzD,oBAAoB;IA0FlC;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAgBxB;;;;OAIG;IACH,OAAO,CAAC,aAAa;IAIrB;;OAEG;IACH,OAAO,CAAC,aAAa;IAyBrB;;;OAGG;IACH,kBAAkB,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO;IAInD;;;OAGG;IACH,OAAO,CAAC,iBAAiB;IAyBzB;;;;;;;;;OASG;IACG,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IA+B7D;;;OAGG;IACH,OAAO,CAAC,sBAAsB;IAY9B;;OAEG;IACH,eAAe,IAAI,MAAM,EAAE;IAI3B;;OAEG;IACH,eAAe,IAAI,MAAM,EAAE;CAG9B"}

package/dist/path-validator.js

@@ -1,5 +1,6 @@
 import * as path from "node:path";
 import * as fs from "node:fs/promises";
+import { expandHomeShorthand, resolveUserPath } from "./path-utils.js";
 class PathValidator {
   config;
   normalizedAllowedPaths;
@@ -10,9 +11,13 @@ class PathValidator {
   constructor(config, logger) {
     this.config = config;
     this.logger = logger;
-    const workingDir = config.workingDirectory || process.cwd();
-    this.normalizedAllowedPaths = config.allowedPaths.map((p) => path.resolve(workingDir, p));
-    this.normalizedBlockedPaths = config.blockedPaths.map((p) => path.normalize(p));
+    const workingDir = resolveUserPath(process.cwd(), config.workingDirectory || process.cwd());
+    this.normalizedAllowedPaths = config.allowedPaths.map(
+      (p) => resolveUserPath(workingDir, p)
+    );
+    this.normalizedBlockedPaths = config.blockedPaths.map(
+      (p) => path.normalize(expandHomeShorthand(p))
+    );
     this.normalizedBlockedExtensions = (config.blockedExtensions || []).map((ext) => {
       const e = ext.startsWith(".") ? ext : `.${ext}`;
       return e.toLowerCase();
@@ -59,11 +64,14 @@ class PathValidator {
         error: "Path cannot be empty"
       };
     }
-    const workingDir = this.config.workingDirectory || process.cwd();
+    const workingDir = resolveUserPath(
+      process.cwd(),
+      this.config.workingDirectory || process.cwd()
+    );
     let resolvedPath;
     let normalizedPath;
     try {
-      resolvedPath = path.isAbsolute(filePath) ? path.resolve(filePath) : path.resolve(workingDir, filePath);
+      resolvedPath = resolveUserPath(workingDir, filePath);
       normalizedPath = resolvedPath;
       try {
         normalizedPath = await fs.realpath(normalizedPath);
@@ -117,7 +125,10 @@ class PathValidator {
    */
   hasPathTraversal(originalPath, normalizedPath) {
     if (originalPath.includes("../") || originalPath.includes("..\\")) {
-      const workingDir = this.config.workingDirectory || process.cwd();
+      const workingDir = resolveUserPath(
+        process.cwd(),
+        this.config.workingDirectory || process.cwd()
+      );
       const relative = path.relative(workingDir, normalizedPath);
       if (relative.startsWith("..")) {
         return true;
@@ -137,7 +148,7 @@ class PathValidator {
    * Check if path matches blocked patterns (blacklist check)
    */
   isPathBlocked(normalizedPath) {
-    const roots = this.normalizedAllowedPaths.length > 0 ? this.normalizedAllowedPaths : [this.config.workingDirectory || process.cwd()];
+    const roots = this.normalizedAllowedPaths.length > 0 ? this.normalizedAllowedPaths : [resolveUserPath(process.cwd(), this.config.workingDirectory || process.cwd())];
     for (const blocked of this.normalizedBlockedPaths) {
       for (const root of roots) {
         const blockedFull = path.isAbsolute(blocked) ? path.normalize(blocked) : path.resolve(root, blocked);
@@ -189,10 +200,13 @@ class PathValidator {
     if (!filePath || filePath.trim() === "") {
       return false;
     }
-    const workingDir = this.config.workingDirectory || process.cwd();
+    const workingDir = resolveUserPath(
+      process.cwd(),
+      this.config.workingDirectory || process.cwd()
+    );
     let normalizedPath;
     try {
-      normalizedPath = path.isAbsolute(filePath) ? path.resolve(filePath) : path.resolve(workingDir, filePath);
+      normalizedPath = resolveUserPath(workingDir, filePath);
       try {
         normalizedPath = await fs.realpath(normalizedPath);
       } catch {

package/dist/path-validator.test.cjs

@@ -1,5 +1,29 @@
 "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 os = __toESM(require("node:os"), 1);
+var path = __toESM(require("node:path"), 1);
 var import_path_validator = require("./path-validator.js");
 const createMockLogger = () => ({
   debug: import_vitest.vi.fn(),
@@ -85,6 +109,23 @@ const createMockLogger = () => ({
         const result = await validator.validatePath("src/file.ts");
         (0, import_vitest.expect)(result.isValid).toBe(true);
       });
+      (0, import_vitest.it)("should expand home-directory shorthand before validation", async () => {
+        const validator = new import_path_validator.PathValidator(
+          {
+            allowedPaths: ["~"],
+            blockedPaths: [],
+            blockedExtensions: [],
+            maxFileSize: 10 * 1024 * 1024,
+            enableBackups: false,
+            backupRetentionDays: 7,
+            workingDirectory: "/workspace/project"
+          },
+          mockLogger
+        );
+        const result = await validator.validatePath("~/notes/file.ts");
+        (0, import_vitest.expect)(result.isValid).toBe(true);
+        (0, import_vitest.expect)(result.normalizedPath).toBe(path.join(os.homedir(), "notes", "file.ts"));
+      });
       (0, import_vitest.it)("should reject paths outside allowed directories", async () => {
         const validator = new import_path_validator.PathValidator(
           {

package/dist/path-validator.test.js

@@ -1,4 +1,6 @@
 import { describe, it, expect, beforeEach, vi } from "vitest";
+import * as os from "node:os";
+import * as path from "node:path";
 import { PathValidator } from "./path-validator.js";
 const createMockLogger = () => ({
   debug: vi.fn(),
@@ -84,6 +86,23 @@ describe("PathValidator", () => {
         const result = await validator.validatePath("src/file.ts");
         expect(result.isValid).toBe(true);
       });
+      it("should expand home-directory shorthand before validation", async () => {
+        const validator = new PathValidator(
+          {
+            allowedPaths: ["~"],
+            blockedPaths: [],
+            blockedExtensions: [],
+            maxFileSize: 10 * 1024 * 1024,
+            enableBackups: false,
+            backupRetentionDays: 7,
+            workingDirectory: "/workspace/project"
+          },
+          mockLogger
+        );
+        const result = await validator.validatePath("~/notes/file.ts");
+        expect(result.isValid).toBe(true);
+        expect(result.normalizedPath).toBe(path.join(os.homedir(), "notes", "file.ts"));
+      });
       it("should reject paths outside allowed directories", async () => {
         const validator = new PathValidator(
           {

package/dist/tool-factory-config.d.ts

@@ -43,7 +43,7 @@ export declare const FileSystemToolsConfigSchema: z.ZodObject<{
     type: "filesystem-tools";
     backupPath?: string | undefined;
     workingDirectory?: string | undefined;
-    enabledTools?: ("read_file" | "write_file" | "edit_file" | "glob_files" | "grep_content" | "read_media_file")[] | undefined;
+    enabledTools?: ("read_file" | "write_file" | "edit_file" | "read_media_file" | "glob_files" | "grep_content")[] | undefined;
 }, {
     type: "filesystem-tools";
     allowedPaths?: string[] | undefined;
@@ -54,7 +54,7 @@ export declare const FileSystemToolsConfigSchema: z.ZodObject<{
     enableBackups?: boolean | undefined;
     backupRetentionDays?: number | undefined;
     workingDirectory?: string | undefined;
-    enabledTools?: ("read_file" | "write_file" | "edit_file" | "glob_files" | "grep_content" | "read_media_file")[] | undefined;
+    enabledTools?: ("read_file" | "write_file" | "edit_file" | "read_media_file" | "glob_files" | "grep_content")[] | undefined;
 }>;
 export type FileSystemToolsConfig = z.output<typeof FileSystemToolsConfigSchema>;
 //# sourceMappingURL=tool-factory-config.d.ts.map

package/dist/tool-factory.cjs

@@ -48,64 +48,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 import_filesystem_service.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 import_core.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 import_core.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 import_filesystem_service.FileSystemService(fileSystemConfig, logger);
+    const createScopedFileSystemService = (context, baseConfig) => {
       const approvalManager = context.services?.approval;
       if (!approvalManager) {
         throw import_core.ToolError.configInvalid(
           "filesystem-tools requires ToolExecutionContext.services.approval"
         );
       }
-      fileSystemService.setDirectoryApprovalChecker(
-        (filePath) => approvalManager.isDirectoryApproved(filePath)
+      const service = new import_filesystem_service.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 import_filesystem_service.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: () => (0, import_read_file_tool.createReadFileTool)(getFileSystemService),

package/dist/tool-factory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool-factory.d.ts","sourceRoot":"","sources":["../src/tool-factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAUvD,OAAO,EAGH,KAAK,qBAAqB,EAC7B,MAAM,0BAA0B,CAAC;AAKlC,eAAO,MAAM,sBAAsB,EAAE,WAAW,CAAC,qBAAqB,CA+GrE,CAAC"}
+{"version":3,"file":"tool-factory.d.ts","sourceRoot":"","sources":["../src/tool-factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAWvD,OAAO,EAGH,KAAK,qBAAqB,EAC7B,MAAM,0BAA0B,CAAC;AAKlC,eAAO,MAAM,sBAAsB,EAAE,WAAW,CAAC,qBAAqB,CAqFrE,CAAC"}