Add path validation helpers, update all handlers

Author: Dimitar Grigorov

filetoolsserver/handler/create_directory.go

@@ -9,32 +9,14 @@ import (
 )
 
 // HandleCreateDirectory creates a new directory or ensures a directory exists.
-// Can create multiple nested directories in one operation (like mkdir -p).
 func (h *Handler) HandleCreateDirectory(ctx context.Context, req *mcp.CallToolRequest, input CreateDirectoryInput) (*mcp.CallToolResult, CreateDirectoryOutput, error) {
-	// Validate path
-	if input.Path == "" {
-		return &mcp.CallToolResult{
-			Content: []mcp.Content{&mcp.TextContent{Text: "path is required and must be a non-empty string"}},
-			IsError: true,
-		}, CreateDirectoryOutput{}, nil
+	v := h.ValidatePath(input.Path)
+	if !v.Ok() {
+		return v.Result, CreateDirectoryOutput{}, nil
 	}
 
-	// Validate path against allowed directories
-	validatedPath, err := h.validatePath(input.Path)
-	if err != nil {
-		return &mcp.CallToolResult{
-			Content: []mcp.Content{&mcp.TextContent{Text: err.Error()}},
-			IsError: true,
-		}, CreateDirectoryOutput{}, nil
-	}
-
-	// Create directory (and any necessary parents)
-	err = os.MkdirAll(validatedPath, 0755)
-	if err != nil {
-		return &mcp.CallToolResult{
-			Content: []mcp.Content{&mcp.TextContent{Text: fmt.Sprintf("failed to create directory: %v", err)}},
-			IsError: true,
-		}, CreateDirectoryOutput{}, nil
+	if err := os.MkdirAll(v.Path, 0755); err != nil {
+		return errorResult(fmt.Sprintf("failed to create directory: %v", err)), CreateDirectoryOutput{}, nil
 	}
 
 	message := fmt.Sprintf("Successfully created directory %s", input.Path)

filetoolsserver/handler/detect.go

@@ -11,41 +11,19 @@ import (
 
 // HandleDetectEncoding detects the encoding of a file
 func (h *Handler) HandleDetectEncoding(ctx context.Context, req *mcp.CallToolRequest, input DetectEncodingInput) (*mcp.CallToolResult, DetectEncodingOutput, error) {
-	// Validate path
-	if input.Path == "" {
-		return &mcp.CallToolResult{
-			Content: []mcp.Content{&mcp.TextContent{Text: "path is required and must be a non-empty string"}},
-			IsError: true,
-		}, DetectEncodingOutput{}, nil
+	v := h.ValidatePath(input.Path)
+	if !v.Ok() {
+		return v.Result, DetectEncodingOutput{}, nil
 	}
 
-	// Validate path against allowed directories
-	validatedPath, err := h.validatePath(input.Path)
+	data, err := os.ReadFile(v.Path)
 	if err != nil {
-		return &mcp.CallToolResult{
-			Content: []mcp.Content{&mcp.TextContent{Text: err.Error()}},
-			IsError: true,
-		}, DetectEncodingOutput{}, nil
+		return errorResult(fmt.Sprintf("failed to read file: %v", err)), DetectEncodingOutput{}, nil
 	}
 
-	// Read file
-	data, err := os.ReadFile(validatedPath)
-	if err != nil {
-		return &mcp.CallToolResult{
-			Content: []mcp.Content{&mcp.TextContent{Text: fmt.Sprintf("failed to read file: %v", err)}},
-			IsError: true,
-		}, DetectEncodingOutput{}, nil
-	}
-
-	// Detect encoding
 	result := encoding.Detect(data)
-
-	// Handle unknown encoding
 	if result.Charset == "" {
-		return &mcp.CallToolResult{
-			Content: []mcp.Content{&mcp.TextContent{Text: "Could not detect encoding"}},
-			IsError: true,
-		}, DetectEncodingOutput{}, nil
+		return errorResult("Could not detect encoding"), DetectEncodingOutput{}, nil
 	}
 
 	return &mcp.CallToolResult{}, DetectEncodingOutput{

filetoolsserver/handler/directory.go

@@ -11,47 +11,26 @@ import (
 
 // HandleListDirectory lists files in a directory with optional pattern filtering
 func (h *Handler) HandleListDirectory(ctx context.Context, req *mcp.CallToolRequest, input ListDirectoryInput) (*mcp.CallToolResult, ListDirectoryOutput, error) {
-	// Validate path
-	if input.Path == "" {
-		return &mcp.CallToolResult{
-			Content: []mcp.Content{&mcp.TextContent{Text: "path is required and must be a non-empty string"}},
-			IsError: true,
-		}, ListDirectoryOutput{}, nil
+	v := h.ValidatePath(input.Path)
+	if !v.Ok() {
+		return v.Result, ListDirectoryOutput{}, nil
 	}
 
-	// Validate path against allowed directories
-	validatedPath, err := h.validatePath(input.Path)
-	if err != nil {
-		return &mcp.CallToolResult{
-			Content: []mcp.Content{&mcp.TextContent{Text: err.Error()}},
-			IsError: true,
-		}, ListDirectoryOutput{}, nil
-	}
-
-	// Default pattern
 	pattern := "*"
 	if input.Pattern != "" {
 		pattern = input.Pattern
 	}
 
-	// Read directory
-	entries, err := os.ReadDir(validatedPath)
+	entries, err := os.ReadDir(v.Path)
 	if err != nil {
-		return &mcp.CallToolResult{
-			Content: []mcp.Content{&mcp.TextContent{Text: fmt.Sprintf("failed to read directory: %v", err)}},
-			IsError: true,
-		}, ListDirectoryOutput{}, nil
+		return errorResult(fmt.Sprintf("failed to read directory: %v", err)), ListDirectoryOutput{}, nil
 	}
 
-	// Filter by pattern and build result
 	var files []string
 	for _, entry := range entries {
 		matched, err := filepath.Match(pattern, entry.Name())
 		if err != nil {
-			return &mcp.CallToolResult{
-				Content: []mcp.Content{&mcp.TextContent{Text: fmt.Sprintf("invalid pattern: %v", err)}},
-				IsError: true,
-			}, ListDirectoryOutput{}, nil
+			return errorResult(fmt.Sprintf("invalid pattern: %v", err)), ListDirectoryOutput{}, nil
 		}
 		if matched {
 			prefix := ""

filetoolsserver/handler/directorytree.go

@@ -13,19 +13,12 @@ import (
 
 // HandleDirectoryTree returns a recursive tree view of files and directories as JSON.
 func (h *Handler) HandleDirectoryTree(ctx context.Context, req *mcp.CallToolRequest, input DirectoryTreeInput) (*mcp.CallToolResult, DirectoryTreeOutput, error) {
-	// Validate input
-	if input.Path == "" {
-		return errorResult(ErrPathRequired.Error()), DirectoryTreeOutput{}, nil
+	v := h.ValidatePath(input.Path)
+	if !v.Ok() {
+		return v.Result, DirectoryTreeOutput{}, nil
 	}
 
-	// Validate path against allowed directories
-	validatedPath, err := h.validatePath(input.Path)
-	if err != nil {
-		return errorResult(err.Error()), DirectoryTreeOutput{}, nil
-	}
-
-	// Check that the path is a directory
-	stat, err := os.Stat(validatedPath)
+	stat, err := os.Stat(v.Path)
 	if err != nil {
 		return errorResult(fmt.Sprintf("failed to access path: %v", err)), DirectoryTreeOutput{}, nil
 	}
@@ -34,7 +27,7 @@ func (h *Handler) HandleDirectoryTree(ctx context.Context, req *mcp.CallToolRequ
 	}
 
 	// Build the tree
-	tree, err := buildTree(validatedPath, input.ExcludePatterns)
+	tree, err := buildTree(v.Path, input.ExcludePatterns)
 	if err != nil {
 		return errorResult(fmt.Sprintf("failed to build directory tree: %v", err)), DirectoryTreeOutput{}, nil
 	}

filetoolsserver/handler/edit_file.go

@@ -13,25 +13,17 @@ import (
 )
 
 // HandleEditFile applies line-based edits to a text file.
-// Each edit replaces exact line sequences with new content.
-// Returns a git-style unified diff showing the changes made.
 func (h *Handler) HandleEditFile(ctx context.Context, req *mcp.CallToolRequest, input EditFileInput) (*mcp.CallToolResult, EditFileOutput, error) {
-	// Validate inputs
-	if input.Path == "" {
-		return errorResult(ErrPathRequired.Error()), EditFileOutput{}, nil
-	}
 	if len(input.Edits) == 0 {
 		return errorResult(ErrEditsRequired.Error()), EditFileOutput{}, nil
 	}
 
-	// Validate path against allowed directories
-	validatedPath, err := h.validatePath(input.Path)
-	if err != nil {
-		return errorResult(err.Error()), EditFileOutput{}, nil
+	v := h.ValidatePath(input.Path)
+	if !v.Ok() {
+		return v.Result, EditFileOutput{}, nil
 	}
 
-	// Read file content
-	data, err := os.ReadFile(validatedPath)
+	data, err := os.ReadFile(v.Path)
 	if err != nil {
 		return errorResult(fmt.Sprintf("failed to read file: %v", err)), EditFileOutput{}, nil
 	}
@@ -53,7 +45,7 @@ func (h *Handler) HandleEditFile(ctx context.Context, req *mcp.CallToolRequest,
 
 	// Write file if not dry run (atomic write)
 	if !input.DryRun {
-		if err := atomicWriteFile(validatedPath, modifiedContent); err != nil {
+		if err := atomicWriteFile(v.Path, modifiedContent); err != nil {
 			return errorResult(fmt.Sprintf("failed to write file: %v", err)), EditFileOutput{}, nil
 		}
 	}

filetoolsserver/handler/fileinfo.go

@@ -11,36 +11,17 @@ import (
 
 // HandleGetFileInfo retrieves detailed metadata about a file or directory
 func (h *Handler) HandleGetFileInfo(ctx context.Context, req *mcp.CallToolRequest, input GetFileInfoInput) (*mcp.CallToolResult, GetFileInfoOutput, error) {
-	// Validate path
-	if input.Path == "" {
-		return &mcp.CallToolResult{
-			Content: []mcp.Content{&mcp.TextContent{Text: "path is required and must be a non-empty string"}},
-			IsError: true,
-		}, GetFileInfoOutput{}, nil
+	v := h.ValidatePath(input.Path)
+	if !v.Ok() {
+		return v.Result, GetFileInfoOutput{}, nil
 	}
 
-	// Validate path against allowed directories
-	validatedPath, err := h.validatePath(input.Path)
+	stat, err := os.Stat(v.Path)
 	if err != nil {
-		return &mcp.CallToolResult{
-			Content: []mcp.Content{&mcp.TextContent{Text: err.Error()}},
-			IsError: true,
-		}, GetFileInfoOutput{}, nil
+		return errorResult(fmt.Sprintf("failed to get file info: %v", err)), GetFileInfoOutput{}, nil
 	}
 
-	// Get file info
-	stat, err := os.Stat(validatedPath)
-	if err != nil {
-		return &mcp.CallToolResult{
-			Content: []mcp.Content{&mcp.TextContent{Text: fmt.Sprintf("failed to get file info: %v", err)}},
-			IsError: true,
-		}, GetFileInfoOutput{}, nil
-	}
-
-	// Get file times (platform-specific)
 	created, accessed, modified := getFileTimes(stat)
-
-	// Get permissions in octal format (last 3 digits)
 	permissions := fmt.Sprintf("%03o", stat.Mode().Perm())
 
 	output := GetFileInfoOutput{
@@ -56,7 +37,6 @@ func (h *Handler) HandleGetFileInfo(ctx context.Context, req *mcp.CallToolReques
 	return &mcp.CallToolResult{}, output, nil
 }
 
-// formatTime formats a time.Time to ISO 8601 format
 func formatTime(t time.Time) string {
 	return t.Format(time.RFC3339)
 }

filetoolsserver/handler/move_file.go

@@ -9,66 +9,27 @@ import (
 )
 
 // HandleMoveFile moves or renames a file or directory.
-// Can move files between directories and rename them in a single operation.
-// Fails if the destination already exists.
 func (h *Handler) HandleMoveFile(ctx context.Context, req *mcp.CallToolRequest, input MoveFileInput) (*mcp.CallToolResult, MoveFileOutput, error) {
-	// Validate source path
-	if input.Source == "" {
-		return &mcp.CallToolResult{
-			Content: []mcp.Content{&mcp.TextContent{Text: "source is required and must be a non-empty string"}},
-			IsError: true,
-		}, MoveFileOutput{}, nil
+	src, dst := h.ValidateSourceDest(input.Source, input.Destination)
+	if !src.Ok() {
+		return src.Result, MoveFileOutput{}, nil
 	}
-
-	// Validate destination path
-	if input.Destination == "" {
-		return &mcp.CallToolResult{
-			Content: []mcp.Content{&mcp.TextContent{Text: "destination is required and must be a non-empty string"}},
-			IsError: true,
-		}, MoveFileOutput{}, nil
-	}
-
-	// Validate source path against allowed directories
-	validatedSource, err := h.validatePath(input.Source)
-	if err != nil {
-		return &mcp.CallToolResult{
-			Content: []mcp.Content{&mcp.TextContent{Text: err.Error()}},
-			IsError: true,
-		}, MoveFileOutput{}, nil
-	}
-
-	// Validate destination path against allowed directories
-	validatedDest, err := h.validatePath(input.Destination)
-	if err != nil {
-		return &mcp.CallToolResult{
-			Content: []mcp.Content{&mcp.TextContent{Text: err.Error()}},
-			IsError: true,
-		}, MoveFileOutput{}, nil
+	if !dst.Ok() {
+		return dst.Result, MoveFileOutput{}, nil
 	}
 
 	// Check if source exists
-	if _, err := os.Stat(validatedSource); os.IsNotExist(err) {
-		return &mcp.CallToolResult{
-			Content: []mcp.Content{&mcp.TextContent{Text: fmt.Sprintf("source does not exist: %s", input.Source)}},
-			IsError: true,
-		}, MoveFileOutput{}, nil
+	if _, err := os.Stat(src.Path); os.IsNotExist(err) {
+		return errorResult(fmt.Sprintf("source does not exist: %s", input.Source)), MoveFileOutput{}, nil
 	}
 
 	// Check if destination already exists
-	if _, err := os.Stat(validatedDest); err == nil {
-		return &mcp.CallToolResult{
-			Content: []mcp.Content{&mcp.TextContent{Text: fmt.Sprintf("destination already exists: %s", input.Destination)}},
-			IsError: true,
-		}, MoveFileOutput{}, nil
+	if _, err := os.Stat(dst.Path); err == nil {
+		return errorResult(fmt.Sprintf("destination already exists: %s", input.Destination)), MoveFileOutput{}, nil
 	}
 
-	// Perform the move/rename operation
-	err = os.Rename(validatedSource, validatedDest)
-	if err != nil {
-		return &mcp.CallToolResult{
-			Content: []mcp.Content{&mcp.TextContent{Text: fmt.Sprintf("failed to move file: %v", err)}},
-			IsError: true,
-		}, MoveFileOutput{}, nil
+	if err := os.Rename(src.Path, dst.Path); err != nil {
+		return errorResult(fmt.Sprintf("failed to move file: %v", err)), MoveFileOutput{}, nil
 	}
 
 	message := fmt.Sprintf("Successfully moved %s to %s", input.Source, input.Destination)

filetoolsserver/handler/read.go

@@ -23,19 +23,17 @@ type encodingResult struct {
 // HandleReadTextFile reads a file in the specified encoding and returns UTF-8 content.
 // If encoding is not specified, it auto-detects the encoding using chunked sampling.
 func (h *Handler) HandleReadTextFile(ctx context.Context, req *mcp.CallToolRequest, input ReadTextFileInput) (*mcp.CallToolResult, ReadTextFileOutput, error) {
-	// Validate input
-	if err := validateReadInput(input); err != nil {
-		return errorResult(err.Error()), ReadTextFileOutput{}, nil
+	// Validate head/tail conflict
+	if input.Head != nil && input.Tail != nil {
+		return errorResult(ErrHeadTailConflict.Error()), ReadTextFileOutput{}, nil
 	}
 
-	// Validate path against allowed directories
-	validatedPath, err := h.validatePath(input.Path)
-	if err != nil {
-		return errorResult(err.Error()), ReadTextFileOutput{}, nil
+	v := h.ValidatePath(input.Path)
+	if !v.Ok() {
+		return v.Result, ReadTextFileOutput{}, nil
 	}
 
-	// Read file
-	data, err := os.ReadFile(validatedPath)
+	data, err := os.ReadFile(v.Path)
 	if err != nil {
 		return errorResult(fmt.Sprintf("failed to read file: %v", err)), ReadTextFileOutput{}, nil
 	}
@@ -65,17 +63,6 @@ func (h *Handler) HandleReadTextFile(ctx context.Context, req *mcp.CallToolReque
 	return &mcp.CallToolResult{}, output, nil
 }
 
-// validateReadInput validates the input parameters for reading a file
-func validateReadInput(input ReadTextFileInput) error {
-	if input.Path == "" {
-		return ErrPathRequired
-	}
-	if input.Head != nil && input.Tail != nil {
-		return ErrHeadTailConflict
-	}
-	return nil
-}
-
 // resolveEncoding determines the encoding to use, either from explicit input or auto-detection
 func resolveEncoding(inputEncoding string, data []byte) (encodingResult, error) {
 	result := encodingResult{}