@dexto/tools-filesystem 1.7.1 → 1.8.0

package/dist/workspace-paths.js

@@ -0,0 +1,51 @@
+import path from "node:path";
+import { DextoRuntimeError } from "@dexto/core/errors";
+import { WorkspaceErrorCodes } from "@dexto/core/workspace";
+import { ToolError } from "@dexto/core/tools";
+function toWorkspaceRelativePath(toolName, workspaceRoot, filePath) {
+  if (!path.isAbsolute(filePath)) {
+    assertRelativePath(toolName, filePath);
+    return filePath.split(path.sep).join("/");
+  }
+  const relativePath = path.relative(workspaceRoot, filePath);
+  if (relativePath === "") {
+    return ".";
+  }
+  if (relativePath.startsWith("..") || path.isAbsolute(relativePath)) {
+    throw ToolError.validationFailed(
+      toolName,
+      `Path must be inside the active workspace: ${filePath}`,
+      { file_path: filePath, workspaceRoot }
+    );
+  }
+  return relativePath.split(path.sep).join("/");
+}
+function isWorkspaceFileNotFound(error) {
+  if (error instanceof DextoRuntimeError && error.code === WorkspaceErrorCodes.FILE_NOT_FOUND) {
+    return true;
+  }
+  return typeof error === "object" && error !== null && "code" in error && error.code === WorkspaceErrorCodes.FILE_NOT_FOUND;
+}
+function assertWorkspaceRelativeGlob(toolName, pattern) {
+  if (path.isAbsolute(pattern) || pattern.split(/[\\/]/).includes("..")) {
+    throw ToolError.validationFailed(
+      toolName,
+      `Glob pattern must stay inside the active workspace: ${pattern}`,
+      { pattern }
+    );
+  }
+}
+function assertRelativePath(toolName, filePath) {
+  if (filePath.split(/[\\/]/).includes("..")) {
+    throw ToolError.validationFailed(
+      toolName,
+      `Path must stay inside the active workspace: ${filePath}`,
+      { file_path: filePath }
+    );
+  }
+}
+export {
+  assertWorkspaceRelativeGlob,
+  isWorkspaceFileNotFound,
+  toWorkspaceRelativePath
+};

package/dist/write-file-tool.cjs

@@ -24,18 +24,21 @@ module.exports = __toCommonJS(write_file_tool_exports);
 var import_node_crypto = require("node:crypto");
 var import_zod = require("zod");
 var import_diff = require("diff");
-var import_core = require("@dexto/core");
+var import_tools = require("@dexto/core/tools");
+var import_errors = require("@dexto/core/errors");
 var import_error_codes = require("./error-codes.js");
 var import_directory_approval = require("./directory-approval.js");
+var import_workspace_paths = require("./workspace-paths.js");
 const previewContentHashCache = /* @__PURE__ */ new Map();
 const FILE_NOT_EXISTS_MARKER = null;
 function computeContentHash(content) {
   return (0, import_node_crypto.createHash)("sha256").update(content, "utf8").digest("hex");
 }
 const WriteFileInputSchema = import_zod.z.object({
-  file_path: import_zod.z.string().min(1).describe("Absolute path where the file should be written"),
+  file_path: import_zod.z.string().min(1).describe(
+    "Path where the file should be written. Relative paths resolve inside the active workspace; absolute paths must stay inside the active workspace."
+  ),
   content: import_zod.z.string().describe("Content to write to the file"),
-  create_dirs: import_zod.z.boolean().optional().default(false).describe("Create parent directories if they don't exist (default: false)"),
   encoding: import_zod.z.enum(["utf-8", "ascii", "latin1", "utf16le"]).optional().default("utf-8").describe("File encoding (default: utf-8)")
 }).strict();
 function generateDiffPreview(filePath, originalContent, newContent) {
@@ -54,10 +57,10 @@ function generateDiffPreview(filePath, originalContent, newContent) {
   };
 }
 function createWriteFileTool(getFileSystemService) {
-  return (0, import_core.defineTool)({
+  return (0, import_tools.defineTool)({
     id: "write_file",
     aliases: ["write"],
-    description: "Write content to a file. Creates a new file or overwrites existing file. Automatically creates backup of existing files before overwriting. Use create_dirs to create parent directories. Requires approval for all write operations. Returns success status, path, bytes written, and backup path if applicable.",
+    description: "Write content to a file inside the active workspace. Creates missing parent directories, creates new files, and overwrites existing files. Relative paths resolve inside the workspace; absolute paths must stay inside it. Requires approval for all write operations. Returns success status, path, bytes written, and display data.",
     inputSchema: WriteFileInputSchema,
     ...(0, import_directory_approval.createDirectoryAccessApprovalHandlers)({
       toolName: "write_file",
@@ -67,9 +70,9 @@ function createWriteFileTool(getFileSystemService) {
       resolvePaths: (input, fileSystemService) => (0, import_directory_approval.resolveFilePath)(fileSystemService.getWorkingDirectory(), input.file_path)
     }),
     presentation: {
-      describeHeader: (input) => (0, import_core.createLocalToolCallHeader)({
+      describeHeader: (input) => (0, import_tools.createLocalToolCallHeader)({
         title: "Write",
-        argsText: (0, import_core.truncateForHeader)(input.file_path, 140)
+        argsText: (0, import_tools.truncateForHeader)(input.file_path, 140)
       }),
       /**
        * Generate preview for approval UI - shows diff or file creation info
@@ -77,6 +80,41 @@ function createWriteFileTool(getFileSystemService) {
        */
       preview: async (input, context) => {
         const { file_path, content } = input;
+        const workspaceManager = context.services?.workspaceManager;
+        if (workspaceManager !== void 0) {
+          const handle = await workspaceManager.open({ intent: "write" });
+          const workspacePath = (0, import_workspace_paths.toWorkspaceRelativePath)(
+            "write_file",
+            handle.context.path,
+            file_path
+          );
+          try {
+            const originalContent = await handle.files.readText(workspacePath);
+            if (context.toolCallId) {
+              previewContentHashCache.set(
+                context.toolCallId,
+                computeContentHash(originalContent)
+              );
+            }
+            return generateDiffPreview(file_path, originalContent, content);
+          } catch (error) {
+            if (!(0, import_workspace_paths.isWorkspaceFileNotFound)(error)) {
+              throw error;
+            }
+            if (context.toolCallId) {
+              previewContentHashCache.set(context.toolCallId, FILE_NOT_EXISTS_MARKER);
+            }
+            return {
+              type: "file",
+              title: "Create file",
+              path: file_path,
+              operation: "create",
+              size: Buffer.byteLength(content, "utf8"),
+              lineCount: content.split("\n").length,
+              content
+            };
+          }
+        }
         const resolvedFileSystemService = await getFileSystemService(context);
         const { path: resolvedPath } = (0, import_directory_approval.resolveFilePath)(
           resolvedFileSystemService.getWorkingDirectory(),
@@ -88,7 +126,7 @@ function createWriteFileTool(getFileSystemService) {
             const originalFile = await resolvedFileSystemService.readFile(resolvedPath);
             originalContent = originalFile.content;
           } catch (error) {
-            if (error instanceof import_core.DextoRuntimeError && error.code === import_error_codes.FileSystemErrorCode.INVALID_PATH) {
+            if (error instanceof import_errors.DextoRuntimeError && error.code === import_error_codes.FileSystemErrorCode.INVALID_PATH) {
               const originalFile = await resolvedFileSystemService.readFileForToolPreview(
                 resolvedPath
               );
@@ -105,7 +143,7 @@ function createWriteFileTool(getFileSystemService) {
           }
           return generateDiffPreview(resolvedPath, originalContent, content);
         } catch (error) {
-          if (error instanceof import_core.DextoRuntimeError && error.code === import_error_codes.FileSystemErrorCode.FILE_NOT_FOUND) {
+          if (error instanceof import_errors.DextoRuntimeError && error.code === import_error_codes.FileSystemErrorCode.FILE_NOT_FOUND) {
             if (context.toolCallId) {
               previewContentHashCache.set(context.toolCallId, FILE_NOT_EXISTS_MARKER);
             }
@@ -127,78 +165,80 @@ function createWriteFileTool(getFileSystemService) {
       }
     },
     async execute(input, context) {
-      const resolvedFileSystemService = await getFileSystemService(context);
-      const { file_path, content, create_dirs, encoding } = input;
-      const { path: resolvedPath } = (0, import_directory_approval.resolveFilePath)(
-        resolvedFileSystemService.getWorkingDirectory(),
+      const { file_path, content, encoding } = input;
+      const handle = await openWorkspace(context, "write_file");
+      const workspacePath = (0, import_workspace_paths.toWorkspaceRelativePath)(
+        "write_file",
+        handle.context.path,
         file_path
       );
       let originalContent = null;
       let fileExistsNow = false;
       try {
-        const originalFile = await resolvedFileSystemService.readFile(resolvedPath);
-        originalContent = originalFile.content;
+        originalContent = await handle.files.readText(workspacePath);
         fileExistsNow = true;
       } catch (error) {
-        if (error instanceof import_core.DextoRuntimeError && error.code === import_error_codes.FileSystemErrorCode.FILE_NOT_FOUND) {
-          originalContent = null;
-          fileExistsNow = false;
-        } else {
+        if (!(0, import_workspace_paths.isWorkspaceFileNotFound)(error)) {
           throw error;
         }
+        originalContent = null;
+        fileExistsNow = false;
       }
       if (context.toolCallId && previewContentHashCache.has(context.toolCallId)) {
         const expectedHash = previewContentHashCache.get(context.toolCallId);
         previewContentHashCache.delete(context.toolCallId);
         if (expectedHash === FILE_NOT_EXISTS_MARKER) {
           if (fileExistsNow) {
-            throw import_core.ToolError.fileModifiedSincePreview("write_file", resolvedPath);
+            throw import_tools.ToolError.fileModifiedSincePreview("write_file", file_path);
           }
         } else if (expectedHash !== null) {
           if (!fileExistsNow) {
-            throw import_core.ToolError.fileModifiedSincePreview("write_file", resolvedPath);
+            throw import_tools.ToolError.fileModifiedSincePreview("write_file", file_path);
           }
           if (originalContent === null) {
-            throw import_core.ToolError.executionFailed(
+            throw import_tools.ToolError.executionFailed(
               "write_file",
               "Expected original file content when fileExistsNow is true"
             );
           }
           const currentHash = computeContentHash(originalContent);
           if (expectedHash !== currentHash) {
-            throw import_core.ToolError.fileModifiedSincePreview("write_file", resolvedPath);
+            throw import_tools.ToolError.fileModifiedSincePreview("write_file", file_path);
           }
         }
       }
-      const result = await resolvedFileSystemService.writeFile(resolvedPath, content, {
-        createDirs: create_dirs,
-        encoding
-      });
+      await handle.files.writeFile(workspacePath, content);
+      const bytesWritten = Buffer.byteLength(content, encoding);
       let _display;
       if (originalContent === null) {
         const lineCount = content.split("\n").length;
         _display = {
           type: "file",
           title: "Create file",
-          path: resolvedPath,
+          path: file_path,
           operation: "create",
-          size: result.bytesWritten,
+          size: bytesWritten,
           lineCount,
           content
         };
       } else {
-        _display = generateDiffPreview(resolvedPath, originalContent, content);
+        _display = generateDiffPreview(file_path, originalContent, content);
       }
       return {
-        success: result.success,
-        path: result.path,
-        bytes_written: result.bytesWritten,
-        ...result.backupPath && { backup_path: result.backupPath },
+        success: true,
+        path: file_path,
+        bytes_written: bytesWritten,
         _display
       };
     }
   });
 }
+async function openWorkspace(context, toolName) {
+  if (!context.services) {
+    throw new Error(`${toolName} requires ToolExecutionContext.services`);
+  }
+  return context.services.workspaceManager.open({ intent: "write" });
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   createWriteFileTool

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

@@ -4,12 +4,11 @@
  * Internal tool for writing content to files (requires approval)
  */
 import { z } from 'zod';
-import type { Tool } from '@dexto/core';
+import type { Tool } from '@dexto/core/tools';
 import type { FileSystemServiceGetter } from './file-tool-types.js';
 declare const WriteFileInputSchema: z.ZodObject<{
     file_path: z.ZodString;
     content: z.ZodString;
-    create_dirs: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     encoding: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
         ascii: "ascii";
         "utf-8": "utf-8";

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

@@ -1 +1 @@
-{"version":3,"file":"write-file-tool.d.ts","sourceRoot":"","sources":["../src/write-file-tool.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAUxB,OAAO,KAAK,EAAE,IAAI,EAAwB,MAAM,aAAa,CAAC;AAG9D,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAuBpE,QAAA,MAAM,oBAAoB;;;;;;;;;;kBAeb,CAAC;AA0Bd;;GAEG;AACH,wBAAgB,mBAAmB,CAC/B,oBAAoB,EAAE,uBAAuB,GAC9C,IAAI,CAAC,OAAO,oBAAoB,CAAC,CAqMnC"}
+{"version":3,"file":"write-file-tool.d.ts","sourceRoot":"","sources":["../src/write-file-tool.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB,OAAO,KAAK,EAGR,IAAI,EAEP,MAAM,mBAAmB,CAAC;AAG3B,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAwBpE,QAAA,MAAM,oBAAoB;;;;;;;;;kBAeb,CAAC;AA0Bd;;GAEG;AACH,wBAAgB,mBAAmB,CAC/B,oBAAoB,EAAE,uBAAuB,GAC9C,IAAI,CAAC,OAAO,oBAAoB,CAAC,CA0NnC"}

package/dist/write-file-tool.js

@@ -3,22 +3,24 @@ import { z } from "zod";
 import { createPatch } from "diff";
 import {
   createLocalToolCallHeader,
-  DextoRuntimeError,
   ToolError,
   defineTool,
   truncateForHeader
-} from "@dexto/core";
+} from "@dexto/core/tools";
+import { DextoRuntimeError } from "@dexto/core/errors";
 import { FileSystemErrorCode } from "./error-codes.js";
 import { createDirectoryAccessApprovalHandlers, resolveFilePath } from "./directory-approval.js";
+import { isWorkspaceFileNotFound, toWorkspaceRelativePath } from "./workspace-paths.js";
 const previewContentHashCache = /* @__PURE__ */ new Map();
 const FILE_NOT_EXISTS_MARKER = null;
 function computeContentHash(content) {
   return createHash("sha256").update(content, "utf8").digest("hex");
 }
 const WriteFileInputSchema = z.object({
-  file_path: z.string().min(1).describe("Absolute path where the file should be written"),
+  file_path: z.string().min(1).describe(
+    "Path where the file should be written. Relative paths resolve inside the active workspace; absolute paths must stay inside the active workspace."
+  ),
   content: z.string().describe("Content to write to the file"),
-  create_dirs: z.boolean().optional().default(false).describe("Create parent directories if they don't exist (default: false)"),
   encoding: z.enum(["utf-8", "ascii", "latin1", "utf16le"]).optional().default("utf-8").describe("File encoding (default: utf-8)")
 }).strict();
 function generateDiffPreview(filePath, originalContent, newContent) {
@@ -40,7 +42,7 @@ function createWriteFileTool(getFileSystemService) {
   return defineTool({
     id: "write_file",
     aliases: ["write"],
-    description: "Write content to a file. Creates a new file or overwrites existing file. Automatically creates backup of existing files before overwriting. Use create_dirs to create parent directories. Requires approval for all write operations. Returns success status, path, bytes written, and backup path if applicable.",
+    description: "Write content to a file inside the active workspace. Creates missing parent directories, creates new files, and overwrites existing files. Relative paths resolve inside the workspace; absolute paths must stay inside it. Requires approval for all write operations. Returns success status, path, bytes written, and display data.",
     inputSchema: WriteFileInputSchema,
     ...createDirectoryAccessApprovalHandlers({
       toolName: "write_file",
@@ -60,6 +62,41 @@ function createWriteFileTool(getFileSystemService) {
        */
       preview: async (input, context) => {
         const { file_path, content } = input;
+        const workspaceManager = context.services?.workspaceManager;
+        if (workspaceManager !== void 0) {
+          const handle = await workspaceManager.open({ intent: "write" });
+          const workspacePath = toWorkspaceRelativePath(
+            "write_file",
+            handle.context.path,
+            file_path
+          );
+          try {
+            const originalContent = await handle.files.readText(workspacePath);
+            if (context.toolCallId) {
+              previewContentHashCache.set(
+                context.toolCallId,
+                computeContentHash(originalContent)
+              );
+            }
+            return generateDiffPreview(file_path, originalContent, content);
+          } catch (error) {
+            if (!isWorkspaceFileNotFound(error)) {
+              throw error;
+            }
+            if (context.toolCallId) {
+              previewContentHashCache.set(context.toolCallId, FILE_NOT_EXISTS_MARKER);
+            }
+            return {
+              type: "file",
+              title: "Create file",
+              path: file_path,
+              operation: "create",
+              size: Buffer.byteLength(content, "utf8"),
+              lineCount: content.split("\n").length,
+              content
+            };
+          }
+        }
         const resolvedFileSystemService = await getFileSystemService(context);
         const { path: resolvedPath } = resolveFilePath(
           resolvedFileSystemService.getWorkingDirectory(),
@@ -110,36 +147,35 @@ function createWriteFileTool(getFileSystemService) {
       }
     },
     async execute(input, context) {
-      const resolvedFileSystemService = await getFileSystemService(context);
-      const { file_path, content, create_dirs, encoding } = input;
-      const { path: resolvedPath } = resolveFilePath(
-        resolvedFileSystemService.getWorkingDirectory(),
+      const { file_path, content, encoding } = input;
+      const handle = await openWorkspace(context, "write_file");
+      const workspacePath = toWorkspaceRelativePath(
+        "write_file",
+        handle.context.path,
         file_path
       );
       let originalContent = null;
       let fileExistsNow = false;
       try {
-        const originalFile = await resolvedFileSystemService.readFile(resolvedPath);
-        originalContent = originalFile.content;
+        originalContent = await handle.files.readText(workspacePath);
         fileExistsNow = true;
       } catch (error) {
-        if (error instanceof DextoRuntimeError && error.code === FileSystemErrorCode.FILE_NOT_FOUND) {
-          originalContent = null;
-          fileExistsNow = false;
-        } else {
+        if (!isWorkspaceFileNotFound(error)) {
           throw error;
         }
+        originalContent = null;
+        fileExistsNow = false;
       }
       if (context.toolCallId && previewContentHashCache.has(context.toolCallId)) {
         const expectedHash = previewContentHashCache.get(context.toolCallId);
         previewContentHashCache.delete(context.toolCallId);
         if (expectedHash === FILE_NOT_EXISTS_MARKER) {
           if (fileExistsNow) {
-            throw ToolError.fileModifiedSincePreview("write_file", resolvedPath);
+            throw ToolError.fileModifiedSincePreview("write_file", file_path);
           }
         } else if (expectedHash !== null) {
           if (!fileExistsNow) {
-            throw ToolError.fileModifiedSincePreview("write_file", resolvedPath);
+            throw ToolError.fileModifiedSincePreview("write_file", file_path);
           }
           if (originalContent === null) {
             throw ToolError.executionFailed(
@@ -149,39 +185,42 @@ function createWriteFileTool(getFileSystemService) {
           }
           const currentHash = computeContentHash(originalContent);
           if (expectedHash !== currentHash) {
-            throw ToolError.fileModifiedSincePreview("write_file", resolvedPath);
+            throw ToolError.fileModifiedSincePreview("write_file", file_path);
           }
         }
       }
-      const result = await resolvedFileSystemService.writeFile(resolvedPath, content, {
-        createDirs: create_dirs,
-        encoding
-      });
+      await handle.files.writeFile(workspacePath, content);
+      const bytesWritten = Buffer.byteLength(content, encoding);
       let _display;
       if (originalContent === null) {
         const lineCount = content.split("\n").length;
         _display = {
           type: "file",
           title: "Create file",
-          path: resolvedPath,
+          path: file_path,
           operation: "create",
-          size: result.bytesWritten,
+          size: bytesWritten,
           lineCount,
           content
         };
       } else {
-        _display = generateDiffPreview(resolvedPath, originalContent, content);
+        _display = generateDiffPreview(file_path, originalContent, content);
       }
       return {
-        success: result.success,
-        path: result.path,
-        bytes_written: result.bytesWritten,
-        ...result.backupPath && { backup_path: result.backupPath },
+        success: true,
+        path: file_path,
+        bytes_written: bytesWritten,
         _display
       };
     }
   });
 }
+async function openWorkspace(context, toolName) {
+  if (!context.services) {
+    throw new Error(`${toolName} requires ToolExecutionContext.services`);
+  }
+  return context.services.workspaceManager.open({ intent: "write" });
+}
 export {
   createWriteFileTool
 };