mcp-fs-shell-windows 0.2.4

package/dist/delete_files/handler.js

@@ -0,0 +1,42 @@
+import fs from "fs/promises";
+import { validatePath } from "../helpers/path.js";
+export async function handleDeleteFiles(paths, recursive, allowedDirectories) {
+    const results = [];
+    const errors = [];
+    await Promise.all(paths.map(async (filePath) => {
+        try {
+            // Validate path is within allowed directories
+            const validPath = await validatePath(filePath, allowedDirectories);
+            // Get file stats to determine if it's a file or directory
+            const stats = await fs.stat(validPath);
+            if (stats.isDirectory()) {
+                if (recursive) {
+                    await fs.rm(validPath, { recursive: true, force: true });
+                    results.push(`Successfully deleted directory: ${filePath}`);
+                }
+                else {
+                    throw new Error("Cannot delete directory without recursive flag");
+                }
+            }
+            else {
+                // Delete the file
+                await fs.unlink(validPath);
+                results.push(`Successfully deleted file: ${filePath}`);
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            errors.push(`Failed to delete ${filePath}: ${errorMessage}`);
+        }
+    }));
+    // Format the results
+    const successCount = results.length;
+    const errorCount = errors.length;
+    let output = `Processed ${successCount + errorCount} paths:\n`;
+    output += `- ${successCount} items deleted successfully\n`;
+    if (errorCount > 0) {
+        output += `- ${errorCount} items failed\n\n`;
+        output += "Errors:\n" + errors.join("\n");
+    }
+    return output;
+}

package/dist/delete_files/schema.js

@@ -0,0 +1,5 @@
+import { z } from "zod";
+export const DeleteFilesArgsSchema = z.object({
+    paths: z.array(z.string()).describe("Paths to files or directories to delete"),
+    recursive: z.boolean().default(false).describe("Whether to recursively delete directories"),
+});

package/dist/delete_files_by_pattern/handler.js

@@ -0,0 +1,46 @@
+import fs from "fs/promises";
+import path from "path";
+import { validatePath } from "../helpers/path.js";
+export async function handleDeleteFilesByPattern(directory, pattern, includeDirectories, allowedDirectories) {
+    const validPath = await validatePath(directory, allowedDirectories);
+    let regex;
+    try {
+        regex = new RegExp(pattern);
+    }
+    catch (error) {
+        throw new Error(`Invalid regular expression: ${pattern}`);
+    }
+    const entries = await fs.readdir(validPath, { withFileTypes: true });
+    const deleted = [];
+    const skipped = [];
+    for (const entry of entries) {
+        if (!regex.test(entry.name))
+            continue;
+        const fullPath = path.join(validPath, entry.name);
+        try {
+            if (entry.isDirectory()) {
+                if (includeDirectories) {
+                    await fs.rm(fullPath, { recursive: true, force: true });
+                    deleted.push(`${fullPath} (directory)`);
+                }
+                else {
+                    skipped.push(`${fullPath} (directory; set includeDirectories: true to delete)`);
+                }
+            }
+            else {
+                await fs.unlink(fullPath);
+                deleted.push(fullPath);
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            skipped.push(`${fullPath} (${errorMessage})`);
+        }
+    }
+    let output = `Pattern "${pattern}" in ${validPath}:\n`;
+    output += `- ${deleted.length} deleted\n`;
+    if (skipped.length > 0) {
+        output += `- ${skipped.length} skipped:\n` + skipped.map((s) => `  ${s}`).join("\n");
+    }
+    return output;
+}

package/dist/delete_files_by_pattern/schema.js

@@ -0,0 +1,6 @@
+import { z } from "zod";
+export const DeleteFilesByPatternArgsSchema = z.object({
+    directory: z.string().describe("Directory to scan (single level; subdirectories are not scanned)."),
+    pattern: z.string().describe("Regular expression matched against each entry name (e.g. '^temp_.*\\.txt$')."),
+    includeDirectories: z.boolean().optional().default(false).describe("Also delete matching directories (recursively). Default: false (files only)."),
+});

package/dist/directory_tree/handler.js

@@ -0,0 +1,7 @@
+import { validatePath } from "../helpers/path.js";
+import { buildDirectoryTree } from "./helpers.js";
+export async function handleDirectoryTree(directoryPath, excludePatterns, allowedDirectories) {
+    const validRootPath = await validatePath(directoryPath, allowedDirectories);
+    const treeData = await buildDirectoryTree(validRootPath, validRootPath, excludePatterns, allowedDirectories);
+    return JSON.stringify(treeData, null, 2);
+}

package/dist/directory_tree/helpers.js

@@ -0,0 +1,47 @@
+import fs from "fs/promises";
+import path from "path";
+import { minimatch } from 'minimatch';
+import { validatePath } from "../helpers/path.js";
+export async function buildDirectoryTree(currentPath, rootPath, excludePatterns = [], allowedDirectories) {
+    const validPath = await validatePath(currentPath, allowedDirectories);
+    const entries = await fs.readdir(validPath, { withFileTypes: true });
+    const result = [];
+    for (const entry of entries) {
+        const entryPath = path.join(currentPath, entry.name);
+        // Check if path should be excluded based on patterns
+        const relativePath = path.relative(rootPath, entryPath);
+        const shouldExclude = excludePatterns.some(pattern => {
+            // Apply same pattern logic as in searchFiles
+            let globPattern = pattern;
+            if (!pattern.includes('*') && !pattern.includes('?')) {
+                if (pattern.includes('/')) {
+                    globPattern = `**/${pattern}/**`;
+                }
+                else {
+                    globPattern = `**/*${pattern}*/**`;
+                }
+            }
+            return minimatch(relativePath, globPattern, {
+                dot: true,
+                nocase: true,
+                matchBase: true
+            });
+        });
+        if (shouldExclude) {
+            continue;
+        }
+        const entryData = {
+            name: entry.name,
+            type: entry.isDirectory() ? 'directory' : 'file'
+        };
+        if (entry.isDirectory()) {
+            entryData.children = await buildDirectoryTree(entryPath, rootPath, excludePatterns, allowedDirectories);
+            // Skip empty directories after exclusion
+            if (entryData.children.length === 0) {
+                continue;
+            }
+        }
+        result.push(entryData);
+    }
+    return result;
+}

package/dist/directory_tree/schema.js

@@ -0,0 +1,5 @@
+import { z } from "zod";
+export const DirectoryTreeArgsSchema = z.object({
+    path: z.string(),
+    excludePatterns: z.array(z.string()).optional().default([]),
+});

package/dist/edit_files/handler.js

@@ -0,0 +1,62 @@
+import fs from "fs/promises";
+import { validatePath } from "../helpers/path.js";
+// Detect the dominant line ending of a file so it can be preserved on write.
+function detectEol(text) {
+    if (text.includes("\r\n"))
+        return "\r\n";
+    if (text.includes("\r"))
+        return "\r";
+    return "\n";
+}
+const toLf = (t) => t.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+const fromLf = (t, eol) => (eol === "\n" ? t : t.replace(/\n/g, eol));
+export async function handleEditFiles(files, allowedDirectories) {
+    const results = [];
+    const errors = [];
+    for (const file of files) {
+        try {
+            const validPath = await validatePath(file.path, allowedDirectories);
+            const raw = await fs.readFile(validPath, "utf-8");
+            const eol = detectEol(raw);
+            let current = toLf(raw);
+            const editLog = [];
+            for (let i = 0; i < file.edits.length; i++) {
+                const { oldString, newString, replaceAll } = file.edits[i];
+                const oldN = toLf(oldString);
+                const newN = toLf(newString);
+                if (oldN.length === 0) {
+                    throw new Error(`Edit ${i + 1}: oldString must not be empty`);
+                }
+                const count = current.split(oldN).length - 1;
+                if (count === 0) {
+                    throw new Error(`Edit ${i + 1}: oldString not found`);
+                }
+                if (!replaceAll && count > 1) {
+                    throw new Error(`Edit ${i + 1}: oldString matched ${count} times (expected exactly 1; set replaceAll: true to replace all)`);
+                }
+                current = current.split(oldN).join(newN);
+                editLog.push(`Edit ${i + 1}: replaced ${replaceAll ? count : 1} occurrence(s)`);
+            }
+            // Write back with the file's original dominant line ending.
+            await fs.writeFile(validPath, fromLf(current, eol), "utf-8");
+            results.push(`File: ${file.path}\n${editLog.join("\n")}`);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            errors.push(`Failed to edit ${file.path}: ${errorMessage}`);
+        }
+    }
+    const successCount = results.length;
+    const errorCount = errors.length;
+    let output = `Processed ${successCount + errorCount} files:\n`;
+    output += `- ${successCount} files edited successfully\n`;
+    if (errorCount > 0) {
+        output += `- ${errorCount} files failed\n\n`;
+        output += "Errors:\n" + errors.join("\n");
+    }
+    if (successCount > 0) {
+        output += "\n\nEdit details:\n" + "=".repeat(40) + "\n";
+        output += results.join("\n" + "=".repeat(40) + "\n");
+    }
+    return output;
+}

package/dist/edit_files/schema.js

@@ -0,0 +1,11 @@
+import { z } from "zod";
+export const EditFilesArgsSchema = z.object({
+    files: z.array(z.object({
+        path: z.string().describe("Path to the file to edit"),
+        edits: z.array(z.object({
+            oldString: z.string().describe("Exact literal text to find. Must not be empty."),
+            newString: z.string().describe("Replacement text. May be empty to delete the matched text."),
+            replaceAll: z.boolean().optional().default(false).describe("When true, replace every occurrence. Default: require exactly one match."),
+        })).describe("Array of edits applied in order"),
+    })).describe("Array of files to edit"),
+});

package/dist/file_diff/handler.js

@@ -0,0 +1,28 @@
+import fs from "fs/promises";
+import { validatePath } from "../helpers/path.js";
+import { createUnifiedDiff } from "../helpers/diff.js";
+export async function handleFileDiff(file1Path, file2Path, allowedDirectories) {
+    const validFile1Path = await validatePath(file1Path, allowedDirectories);
+    const validFile2Path = await validatePath(file2Path, allowedDirectories);
+    try {
+        // Read both files
+        const file1Content = await fs.readFile(validFile1Path, 'utf-8');
+        const file2Content = await fs.readFile(validFile2Path, 'utf-8');
+        // Create a unified diff
+        const diff = createUnifiedDiff(file1Content, file2Content, file1Path, file2Path);
+        // Format diff with appropriate number of backticks
+        let numBackticks = 3;
+        while (diff.includes('`'.repeat(numBackticks))) {
+            numBackticks++;
+        }
+        const formattedDiff = `${'`'.repeat(numBackticks)}diff\n${diff}${'`'.repeat(numBackticks)}\n\n`;
+        if (diff.trim() === '') {
+            return `Files are identical.`;
+        }
+        return formattedDiff;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        throw new Error(`Error comparing files: ${errorMessage}`);
+    }
+}

package/dist/file_diff/schema.js

@@ -0,0 +1,5 @@
+import { z } from "zod";
+export const FileDiffArgsSchema = z.object({
+    file1: z.string(),
+    file2: z.string(),
+});

package/dist/file_info/handler.js

@@ -0,0 +1,30 @@
+import fs from "fs/promises";
+import { validatePath } from "../helpers/path.js";
+export async function getFileStats(filePath) {
+    const stats = await fs.stat(filePath);
+    return {
+        size: stats.size,
+        created: stats.birthtime,
+        modified: stats.mtime,
+        accessed: stats.atime,
+        isDirectory: stats.isDirectory(),
+        isFile: stats.isFile(),
+        permissions: stats.mode.toString(8).slice(-3),
+    };
+}
+export async function handleGetFileInfo(filePath, allowedDirectories) {
+    const validPath = await validatePath(filePath, allowedDirectories);
+    const stats = await fs.stat(validPath);
+    const formattedInfo = {
+        path: filePath,
+        size: `${stats.size} bytes`,
+        type: stats.isDirectory() ? 'directory' : (stats.isFile() ? 'file' : 'other'),
+        created: stats.birthtime.toISOString(),
+        modified: stats.mtime.toISOString(),
+        accessed: stats.atime.toISOString(),
+        permissions: stats.mode.toString(8).slice(-3)
+    };
+    return Object.entries(formattedInfo)
+        .map(([key, value]) => `${key}: ${value}`)
+        .join("\n");
+}

package/dist/file_info/schema.js

@@ -0,0 +1,4 @@
+import { z } from "zod";
+export const GetFileInfoArgsSchema = z.object({
+    path: z.string(),
+});

package/dist/fuzzy_find_files/handler.js

@@ -0,0 +1,74 @@
+import fs from "fs/promises";
+import path from "path";
+import { validatePath } from "../helpers/path.js";
+function levenshtein(a, b) {
+    if (a === b)
+        return 0;
+    if (a.length === 0)
+        return b.length;
+    if (b.length === 0)
+        return a.length;
+    let prev = new Array(b.length + 1);
+    let curr = new Array(b.length + 1);
+    for (let j = 0; j <= b.length; j++)
+        prev[j] = j;
+    for (let i = 1; i <= a.length; i++) {
+        curr[0] = i;
+        for (let j = 1; j <= b.length; j++) {
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            curr[j] = Math.min(prev[j] + 1, curr[j - 1] + 1, prev[j - 1] + cost);
+        }
+        [prev, curr] = [curr, prev];
+    }
+    return prev[b.length];
+}
+export async function handleFuzzyFindFiles(query, searchPath, recursive, maxResults, scanLimit, allowedDirectories) {
+    const validRoot = await validatePath(searchPath, allowedDirectories);
+    const q = query.toLowerCase();
+    const candidates = [];
+    let scanned = 0;
+    let truncated = false;
+    async function walk(dir) {
+        if (truncated)
+            return;
+        let entries;
+        try {
+            entries = await fs.readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (truncated)
+                break;
+            scanned++;
+            if (scanned > scanLimit) {
+                truncated = true;
+                break;
+            }
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (recursive) {
+                    await walk(fullPath);
+                }
+            }
+            else if (entry.isFile()) {
+                const rel = path.relative(validRoot, fullPath).toLowerCase();
+                const name = entry.name.toLowerCase();
+                const distance = Math.min(levenshtein(q, name), levenshtein(q, rel));
+                candidates.push({ path: fullPath, distance });
+            }
+        }
+    }
+    await walk(validRoot);
+    candidates.sort((a, b) => a.distance - b.distance || a.path.localeCompare(b.path));
+    const top = candidates.slice(0, maxResults);
+    if (top.length === 0) {
+        return `No files found for query: ${query} (scanned ${scanned} entries)`;
+    }
+    let output = `Top ${top.length} fuzzy matches for "${query}" (scanned ${scanned} entries${truncated ? ", stopped at scan limit" : ""}):\n`;
+    top.forEach((c, i) => {
+        output += `${i + 1}. (distance ${c.distance}) ${c.path}\n`;
+    });
+    return output;
+}

package/dist/fuzzy_find_files/schema.js

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export const FuzzyFindFilesArgsSchema = z.object({
+    query: z.string().describe("Search query to match against file names/paths (typo-tolerant)."),
+    path: z.string().describe("Root directory to search in."),
+    recursive: z.boolean().optional().default(true).describe("Recursively search subdirectories. Default: true."),
+    maxResults: z.number().int().min(1).max(50).optional().default(5).describe("Maximum number of results to return. Default: 5."),
+    scanLimit: z.number().int().min(1).optional().default(20000).describe("Maximum entries to scan before stopping (safety for huge trees/network shares). Default: 20000."),
+});

package/dist/helpers/checksum.js

@@ -0,0 +1,10 @@
+import fs from "fs/promises";
+import crypto from "crypto";
+export async function calculateFileHash(filePath, algorithm = "sha256") {
+    // Read the file
+    const data = await fs.readFile(filePath);
+    // Calculate hash
+    const hash = crypto.createHash(algorithm);
+    hash.update(data);
+    return hash.digest("hex");
+}

package/dist/helpers/diff.js

@@ -0,0 +1,10 @@
+import { createTwoFilesPatch } from 'diff';
+export function normalizeLineEndings(text) {
+    return text.replace(/\r\n/g, '\n');
+}
+export function createUnifiedDiff(originalContent, newContent, originalFilePath = 'file1', newFilePath = 'file2') {
+    // Ensure consistent line endings for diff
+    const normalizedOriginal = normalizeLineEndings(originalContent);
+    const normalizedNew = normalizeLineEndings(newContent);
+    return createTwoFilesPatch(originalFilePath, newFilePath, normalizedOriginal, normalizedNew, 'original', 'modified');
+}

package/dist/helpers/path.js

@@ -0,0 +1,87 @@
+import fs from "fs/promises";
+import path from "path";
+import os from 'os';
+// Normalize all paths consistently
+export function normalizePath(p) {
+    return path.normalize(p);
+}
+export function expandHome(filepath) {
+    if (filepath.startsWith('~/') || filepath === '~') {
+        return path.join(os.homedir(), filepath.slice(1));
+    }
+    return filepath;
+}
+// Security utilities
+export async function validatePath(requestedPath, allowedDirectories) {
+    const expandedPath = expandHome(requestedPath);
+    const absolute = path.isAbsolute(expandedPath)
+        ? path.resolve(expandedPath)
+        : path.resolve(process.cwd(), expandedPath);
+    const normalizedRequested = normalizePath(absolute);
+    // Check if path is within allowed directories
+    const isAllowed = allowedDirectories.some(dir => normalizedRequested.startsWith(dir));
+    if (!isAllowed) {
+        throw new Error(`Access denied - path outside allowed directories: ${absolute} not in ${allowedDirectories.join(', ')}`);
+    }
+    // Handle symlinks by checking their real path
+    try {
+        const realPath = await fs.realpath(absolute);
+        const normalizedReal = normalizePath(realPath);
+        const isRealPathAllowed = allowedDirectories.some(dir => normalizedReal.startsWith(dir));
+        if (!isRealPathAllowed) {
+            throw new Error("Access denied - symlink target outside allowed directories");
+        }
+        return realPath;
+    }
+    catch (error) {
+        // Target doesn't exist yet: walk up to the nearest existing ancestor
+        // and verify it is within an allowed directory
+        let ancestor = path.dirname(absolute);
+        let realAncestor = null;
+        while (true) {
+            try {
+                realAncestor = await fs.realpath(ancestor);
+                break;
+            }
+            catch {
+                const up = path.dirname(ancestor);
+                if (up === ancestor) {
+                    break;
+                }
+                ancestor = up;
+            }
+        }
+        if (realAncestor === null) {
+            throw new Error(`Parent directory does not exist: ${path.dirname(absolute)}`);
+        }
+        const normalizedAncestor = normalizePath(realAncestor);
+        const isAncestorAllowed = allowedDirectories.some(dir => normalizedAncestor.startsWith(dir));
+        if (!isAncestorAllowed) {
+            throw new Error("Access denied - parent directory outside allowed directories");
+        }
+        return absolute;
+    }
+}
+// Create a directory (and parents) if needed. Tolerates volume roots,
+// which Node's recursive mkdir can reject with EPERM on Windows.
+export async function ensureDirectoryExists(dir) {
+    try {
+        const stats = await fs.stat(dir);
+        if (stats.isDirectory()) {
+            return;
+        }
+    }
+    catch {
+        // Doesn't exist or is inaccessible - fall through and try to create
+    }
+    try {
+        await fs.mkdir(dir, { recursive: true });
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === 'EPERM' || code === 'EEXIST') {
+            return;
+        }
+        throw error;
+    }
+}

package/dist/index.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+import fs from "fs/promises";
+import path from "path";
+import { normalizePath, expandHome } from "./helpers/path.js";
+import { FilesystemServer } from "./server.js";
+// Command line argument parsing
+const args = process.argv.slice(2);
+if (args.length === 0) {
+    console.error("Usage: mcp-fs-shell-windows <allowed-directory> [additional-directories...]");
+    process.exit(1);
+}
+// Store allowed directories in normalized form
+const allowedDirectories = args.map(dir => normalizePath(path.resolve(expandHome(dir))));
+// Validate that all directories exist and are accessible
+(async () => {
+    try {
+        await Promise.all(args.map(async (dir) => {
+            try {
+                const stats = await fs.stat(dir);
+                if (!stats.isDirectory()) {
+                    console.error(`Warning: ${dir} is not a directory; continuing without it`);
+                }
+            }
+            catch (error) {
+                console.error(`Warning: cannot access ${dir} (offline or invalid); continuing without it`);
+            }
+        }));
+        // Start server
+        const server = new FilesystemServer(allowedDirectories);
+        await server.connect();
+    }
+    catch (error) {
+        console.error("Fatal error running server:", error);
+        process.exit(1);
+    }
+})();

package/dist/list_directory/handler.js

@@ -0,0 +1,42 @@
+import fs from "fs/promises";
+import path from "path";
+import { validatePath } from "../helpers/path.js";
+import { minimatch } from "minimatch";
+export async function handleListDirectory(directoryPath, allowedDirectories, type = "all", ignore = [], offset = 1, limit = 100, includeSizes = true) {
+    const validPath = await validatePath(directoryPath, allowedDirectories);
+    const entries = await fs.readdir(validPath, { withFileTypes: true });
+    let filtered = entries.filter((entry) => {
+        if (type === "files" && !entry.isFile())
+            return false;
+        if (type === "directories" && !entry.isDirectory())
+            return false;
+        return !ignore.some((pattern) => minimatch(entry.name, pattern, { dot: true }));
+    });
+    // Stable ordering for pagination
+    filtered = filtered.sort((a, b) => a.name.toLowerCase().localeCompare(b.name.toLowerCase()));
+    const total = filtered.length;
+    if (total === 0) {
+        return `No entries in ${validPath}`;
+    }
+    if (offset > total) {
+        return `No entries in ${validPath} (offset ${offset} is beyond ${total} entries)`;
+    }
+    const start = offset - 1;
+    const shown = filtered.slice(start, start + limit);
+    const lines = [];
+    for (const entry of shown) {
+        let sizeText = "";
+        if (includeSizes && entry.isFile()) {
+            try {
+                const stats = await fs.stat(path.join(validPath, entry.name));
+                sizeText = ` (${stats.size} bytes)`;
+            }
+            catch {
+                sizeText = "";
+            }
+        }
+        lines.push(`${entry.isDirectory() ? "[DIR]" : "[FILE]"} ${entry.name}${sizeText}`);
+    }
+    const end = start + shown.length;
+    return `Showing ${offset}-${end} of ${total} entries in ${validPath}\n` + lines.join("\n");
+}

package/dist/list_directory/schema.js

@@ -0,0 +1,9 @@
+import { z } from "zod";
+export const ListDirectoryArgsSchema = z.object({
+    path: z.string(),
+    type: z.enum(["files", "directories", "all"]).optional().default("all").describe("What to return: \"files\", \"directories\", or \"all\". Default: \"all\"."),
+    ignore: z.array(z.string()).optional().default([]).describe("Glob patterns to skip (e.g. [\"node_modules\", \"dist\", \"*.log\"])."),
+    offset: z.number().int().min(1).optional().default(1).describe("1-indexed result number to start from. Default: 1."),
+    limit: z.number().int().min(1).optional().default(100).describe("Maximum number of entries to return. Default: 100."),
+    includeSizes: z.boolean().optional().default(true).describe("Include file sizes in the listing. Default: true (one stat per shown file entry)."),
+});