mcp-fs-shell-windows 0.2.4

package/LICENSE

@@ -0,0 +1,23 @@
+MIT License
+
+Copyright (c) 2024-2025 Anthropic, PBC (original @modelcontextprotocol/server-filesystem)
+Copyright (c) 2025 fabienvauchelles (mcp-filesystem-extended base fork)
+Copyright (c) 2026 Gerard DeLuca (robustness patches, shell tools, Windows hardening)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,147 @@
+# mcp-fs-shell-windows — filesystem + standalone Windows shell MCP server
+
+A Node.js MCP server exposing **filesystem operations** and a **standalone shell** as tools. Heavily extended fork of [fabienvauchelles/mcp-filesystem-extended](https://github.com/fabienvauchelles/mcp-filesystem-extended), which itself extends the official [`@modelcontextprotocol/server-filesystem`](https://github.com/modelcontextprotocol/servers/tree/main/src/filesystem).
+
+Developed and tested primarily on **Windows**: drive-letter roots (`C:\`, `D:\`) and UNC network-share roots (`\\server\\share`) are first-class, and the shell tools run commands through `cmd.exe` byte-for-byte — including background job management and detached interactive console windows.
+
+## Provenance
+
+| Layer | Source |
+|---|---|
+| Official base | `@modelcontextprotocol/server-filesystem` (Anthropic, PBC; MIT) |
+| Base fork | [fabienvauchelles/mcp-filesystem-extended](https://github.com/fabienvauchelles/mcp-filesystem-extended) @ `b6c317a` (MIT) |
+| This fork | v0.2.1 tool parity + `transfer_files` rename, robustness patches, 8 shell tools (v0.2.2), verbatim argv (v0.2.4) — see [Differences](#differences-from-the-base-fork) |
+
+## Features
+
+- **23 filesystem tools** — batched read/write/append/delete, move/copy, line-number patching, search (name / glob / regex / fuzzy), tree, counts, checksums, diffs, exact-match text editing. Confined to the allowed directories passed on the command line.
+- **8 shell tools** — synchronous, background, and interactive command execution implemented *inside the MCP server process*: no client-side permission toggles, survives client restarts, works with any MCP client.
+- **Windows-first** — drive roots, UNC roots, `cmd.exe /d /c` with verbatim argv, whole-process-tree kills (`taskkill /T /F`), detached interactive console windows.
+- **NAS-safe startup** — an allowed directory that is missing or offline (e.g., a powered-down network share) logs a warning and the server continues instead of exiting.
+
+## Requirements
+
+- Node.js >= 20 (developed and tested on Node 22).
+- Windows for the shell tools (they spawn `cmd.exe`, `taskkill`, and `powershell`). The filesystem tools work on any platform Node runs on.
+- `shell_python` requires Python on the system PATH.
+
+## Build
+
+```bat
+npm ci
+npm run build
+```
+
+Run the server:
+
+```bat
+node dist\index.js <allowed-dir> [more-dirs...]
+```
+
+## Usage
+
+Example MCP client config (Claude Desktop / LM Studio `mcp.json` style):
+
+```json
+{
+  "mcpServers": {
+    "filesystem": {
+      "command": "node",
+      "args": [
+        "C:/path/to/repo/dist/index.js",
+        "C:\\",
+        "D:\\",
+        "\\\\server\\share"
+      ]
+    }
+  }
+}
+```
+
+The filesystem tools can only touch the passed directories (and anything under them). A root that cannot be accessed at startup logs a warning and is skipped; the server keeps running. Note that the shell tools are **not** root-restricted — see [Security](#security).
+
+### Filesystem tools (23)
+
+| Tool | Purpose |
+|---|---|
+| `read_files` | Read one or more files, line-numbered; `offset`/`limit` paging |
+| `write_new_files` | Create files (per-file `overwrite`, optional `base64` encoding) |
+| `append_files` | Append to files (creates them if missing) |
+| `delete_files` | Delete files/directories (`recursive`) |
+| `copy_file` | Copy files/directories (`recursive`, `overwrite`) |
+| `transfer_files` | Move/rename items (`overwrite`, creates parent dirs) |
+| `patch_files` | Patch by line ranges (`replace`/`insertBefore`/`delete`, `dryRun`, git-diff output) |
+| `create_directories` | Create directory paths (nested chains) |
+| `list_directory` | Single-level listing (sizes, pagination, type filter, ignore globs) |
+| `directory_tree` | Recursive tree view (JSON) with exclusion patterns |
+| `search_files` | Recursive case-insensitive name-substring search |
+| `search_regex` | Content grep over a single file or directory tree (paged) |
+| `search_glob` | Glob-based file search (e.g. `**/*.ts`, paged) |
+| `fuzzy_find_files` | Typo-tolerant name/path search (Levenshtein) |
+| `delete_files_by_pattern` | Regex delete within a single directory |
+| `count_lines` | Line counts with filters |
+| `file_diff` | Unified diff of two files |
+| `content_diff` | Unified diff of two strings |
+| `checksum_files` | md5/sha1/sha256/sha512 for files |
+| `checksum_files_verif` | Verify files against expected hashes |
+| `get_file_info` | Size, timestamps, type, permissions |
+| `edit_files` | Exact-match text replacement, EOL-tolerant |
+| `list_allowed_directories` | List the allowed root directories |
+
+### Shell tools (8, Windows-only)
+
+User commands are spawned as `cmd.exe /d /c <command>` with **verbatim argv** — quotes, redirects, and metacharacters arrive byte-for-byte (Node `windowsVerbatimArguments`), and `/d` skips AutoRun registry entries.
+
+| Tool | Purpose |
+|---|---|
+| `shell_run` | Synchronous command (default 5 s, max 28 s); non-zero exit or timeout returns the captured stdout/stderr instead of hiding it |
+| `shell_test` | Test wrapper (runs with `CI=true`); never errors on a failing test |
+| `shell_start` | Background job — returns immediately with a job ID; auto-kills at `timeout_hours` (max 10); 256 KB in-memory tail + log file |
+| `shell_check` | Job status, stdout/stderr tails, log file path |
+| `shell_cancel` | Kill the whole process tree (`taskkill /T /F`, with PID-liveness fallback) |
+| `shell_terminal` | Open a visible, separate, interactive `cmd /k` console window running the command; the window persists after the command finishes; close it with `shell_cancel` |
+| `shell_python` | Run a Python snippet (temp `.py` + system Python) |
+| `shell_cwd` | Get/set the default working directory for the other shell tools (every tool also accepts a per-call `cwd`) |
+
+Practical notes:
+
+- Background jobs live in an **in-memory registry** inside the server process: the table is lost on server restart, but job log files persist (under `%TEMP%\mcp-filesystem-extended\shell-jobs`).
+- `timeout /t` can fail when stdin is not an interactive console — use `ping -n N 127.0.0.1 >nul` for sleeps.
+- Synchronous calls are bounded (max 28 s) so they cannot wedge the MCP request channel; anything longer should go through `shell_start`.
+
+## Docker
+
+```bat
+docker build -t mcp/filesystem-extended .
+docker run -i --rm -v /path/to/dir:/data mcp/filesystem-extended /data
+```
+
+The filesystem tools work in the image; the shell tools require a Windows host with `cmd.exe`.
+
+## Differences from the base fork
+
+**v0.2.1 — official-server parity:** head/tail reads (`offset`/`limit` in `read_files`), sizes in listings, `overwrite` in `write_new_files`, exact-match text editing (`edit_files`).
+
+**`transfer_files` (renamed from `move_files`):** the canonical move/rename tool. Renamed because at least one MCP client (observed in LM Studio) silently drops tools named `move_files`/`mv_files` from the exposed tool list; `transfer_files` is registered last in the tools array.
+
+**Robustness patches:**
+
+- Missing/offline allowed roots warn at startup instead of exiting (NAS-down safe).
+- `validatePath` walks to the nearest existing ancestor, so writes under brand-new nested directories work.
+- `ensureDirectoryExists` at all `mkdir` sites (Node EPERM quirk on drive-root writes).
+- Move-handler destination checks use errno `ENOENT`, so moves to fresh destinations succeed.
+- `zod` pinned to `^3.23.8` (zod v4 breaks the SDK's schema conversion).
+
+**v0.2.2 — shell tools** as listed above, with whole-process-tree kills and the detached interactive console window.
+
+**v0.2.4 — verbatim argv:** `windowsVerbatimArguments` + `/d` on all user-command spawns (run/test/start and the terminal launcher).
+
+## Security
+
+- The filesystem tools are confined to the allowed directories passed at startup (and their subtrees).
+- The shell tools are **not** confined: anything the server process's user can execute will run, including against reachable network shares. Grant this server the same trust you would grant an unsandboxed shell.
+- The server communicates over stdio and opens no network endpoints of its own.
+
+## License
+
+MIT — see [LICENSE](./LICENSE). This project derives from MIT-licensed code (Anthropic, PBC; fabienvauchelles); all copyright notices are in the LICENSE file.

package/dist/append_files/handler.js

@@ -0,0 +1,32 @@
+import fs from "fs/promises";
+import path from "path";
+import { validatePath, ensureDirectoryExists } from "../helpers/path.js";
+export async function handleAppendFiles(files, allowedDirectories) {
+    const results = [];
+    const errors = [];
+    await Promise.all(files.map(async (file) => {
+        try {
+            const validPath = await validatePath(file.path, allowedDirectories);
+            // Ensure parent directory exists
+            const directory = path.dirname(validPath);
+            await ensureDirectoryExists(directory);
+            // Append content to file (create if doesn't exist)
+            await fs.appendFile(validPath, file.content, "utf-8");
+            results.push(`Successfully appended to ${file.path}`);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            errors.push(`Failed to append to file ${file.path}: ${errorMessage}`);
+        }
+    }));
+    // Format the results
+    const successCount = results.length;
+    const errorCount = errors.length;
+    let output = `Processed ${successCount + errorCount} files:\n`;
+    output += `- ${successCount} files appended successfully\n`;
+    if (errorCount > 0) {
+        output += `- ${errorCount} files failed\n\n`;
+        output += "Errors:\n" + errors.join("\n");
+    }
+    return output;
+}

package/dist/append_files/schema.js

@@ -0,0 +1,7 @@
+import { z } from "zod";
+export const AppendFilesArgsSchema = z.object({
+    files: z.array(z.object({
+        path: z.string().describe("Path to the file to append to"),
+        content: z.string().describe("Content to append to the file"),
+    })).describe("Array of files to append to"),
+});

package/dist/checksum_files/handler.js

@@ -0,0 +1,33 @@
+import { validatePath } from "../helpers/path.js";
+import { calculateFileHash } from "../helpers/checksum.js";
+export async function handleChecksumFiles(filePaths, algorithm, allowedDirectories) {
+    const results = [];
+    const errors = [];
+    await Promise.all(filePaths.map(async (filePath) => {
+        try {
+            // Validate the path
+            const validPath = await validatePath(filePath, allowedDirectories);
+            // Calculate the hash
+            const hash = await calculateFileHash(validPath, algorithm);
+            results.push({ path: filePath, hash });
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            errors.push({ path: filePath, error: errorMessage });
+        }
+    }));
+    // Format the results
+    let output = `Checksums (${algorithm}):\n\n`;
+    if (results.length > 0) {
+        for (const result of results) {
+            output += `${result.hash}  ${result.path}\n`;
+        }
+    }
+    if (errors.length > 0) {
+        output += "\nErrors:\n";
+        for (const error of errors) {
+            output += `${error.path}: ${error.error}\n`;
+        }
+    }
+    return output;
+}

package/dist/checksum_files/schema.js

@@ -0,0 +1,5 @@
+import { z } from "zod";
+export const ChecksumFilesArgsSchema = z.object({
+    paths: z.array(z.string()).describe("Paths to the files to generate checksums for"),
+    algorithm: z.enum(["md5", "sha1", "sha256", "sha512"]).default("sha256").describe("Hash algorithm to use"),
+});

package/dist/checksum_files_verif/handler.js

@@ -0,0 +1,66 @@
+import { validatePath } from "../helpers/path.js";
+import { calculateFileHash } from "../helpers/checksum.js";
+import { validateHash } from "./helpers.js";
+export async function handleChecksumFilesVerif(files, algorithm, allowedDirectories) {
+    const results = [];
+    const errors = [];
+    await Promise.all(files.map(async (file) => {
+        try {
+            // Validate the path
+            const validPath = await validatePath(file.path, allowedDirectories);
+            // Calculate the hash
+            const actualHash = await calculateFileHash(validPath, algorithm);
+            // Compare with expected hash
+            const isValid = validateHash(actualHash, file.expectedHash);
+            results.push({
+                path: file.path,
+                expectedHash: file.expectedHash,
+                actualHash,
+                valid: isValid
+            });
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            errors.push({
+                path: file.path,
+                expectedHash: file.expectedHash,
+                error: errorMessage
+            });
+        }
+    }));
+    // Count successes and failures
+    const validCount = results.filter(r => r.valid).length;
+    const invalidCount = results.filter(r => !r.valid).length;
+    const errorCount = errors.length;
+    // Format the results
+    let output = `Checksum Verification Results (${algorithm}):\n`;
+    output += `✅ Valid: ${validCount}\n`;
+    output += `❌ Invalid: ${invalidCount}\n`;
+    output += `⚠️ Errors: ${errorCount}\n\n`;
+    // Valid files
+    if (validCount > 0) {
+        output += "Valid Files:\n";
+        for (const result of results.filter(r => r.valid)) {
+            output += `✓ ${result.path}\n`;
+        }
+        output += "\n";
+    }
+    // Invalid files
+    if (invalidCount > 0) {
+        output += "Invalid Files:\n";
+        for (const result of results.filter(r => !r.valid)) {
+            output += `✗ ${result.path}\n`;
+            output += `  Expected: ${result.expectedHash}\n`;
+            output += `  Actual:   ${result.actualHash}\n`;
+        }
+        output += "\n";
+    }
+    // Errors
+    if (errorCount > 0) {
+        output += "Errors:\n";
+        for (const error of errors) {
+            output += `! ${error.path}: ${error.error}\n`;
+        }
+    }
+    return output;
+}

package/dist/checksum_files_verif/helpers.js

@@ -0,0 +1,6 @@
+export function validateHash(hash, expectedHash) {
+    // Normalize hashes for comparison (convert to lowercase, trim)
+    const normalizedHash = hash.toLowerCase().trim();
+    const normalizedExpected = expectedHash.toLowerCase().trim();
+    return normalizedHash === normalizedExpected;
+}

package/dist/checksum_files_verif/schema.js

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export const ChecksumFilesVerifArgsSchema = z.object({
+    files: z.array(z.object({
+        path: z.string().describe("Path to the file to verify"),
+        expectedHash: z.string().describe("Expected hash value to compare against"),
+    })).describe("Array of files to verify with their expected hashes"),
+    algorithm: z.enum(["md5", "sha1", "sha256", "sha512"]).default("sha256").describe("Hash algorithm to use"),
+});

package/dist/content_diff/handler.js

@@ -0,0 +1,11 @@
+import { createUnifiedDiff } from "../helpers/diff.js";
+export async function handleContentDiff(content1, content2, label1, label2) {
+    // Generate a diff between the two content strings
+    const diff = createUnifiedDiff(content1, content2, label1, label2);
+    // Format the output with code fence
+    let numBackticks = 3;
+    while (diff.includes('`'.repeat(numBackticks))) {
+        numBackticks++;
+    }
+    return `${'`'.repeat(numBackticks)}diff\n${diff}${'`'.repeat(numBackticks)}`;
+}

package/dist/content_diff/schema.js

@@ -0,0 +1,7 @@
+import { z } from "zod";
+export const ContentDiffArgsSchema = z.object({
+    content1: z.string().describe("First content string to compare"),
+    content2: z.string().describe("Second content string to compare"),
+    label1: z.string().optional().default("original").describe("Label for the first content"),
+    label2: z.string().optional().default("modified").describe("Label for the second content"),
+});

package/dist/copy_files/handler.js

@@ -0,0 +1,43 @@
+import fs from "fs/promises";
+import { copyDir } from "./helpers.js";
+import { validatePath, ensureDirectoryExists } from "../helpers/path.js";
+export async function handleCopyFile(sourcePath, destinationPath, recursive, overwrite, allowedDirectories) {
+    const validSourcePath = await validatePath(sourcePath, allowedDirectories);
+    const validDestPath = await validatePath(destinationPath, allowedDirectories);
+    try {
+        // Check if source exists
+        const sourceStats = await fs.stat(validSourcePath);
+        // Check if destination already exists
+        try {
+            await fs.access(validDestPath);
+            if (!overwrite) {
+                throw new Error(`Destination already exists: ${destinationPath}. Use overwrite=true to replace it.`);
+            }
+        }
+        catch (error) {
+            // This is expected for new destinations
+            if (!(error instanceof Error) || !error.message.includes('ENOENT')) {
+                throw error; // If error is something else, rethrow it
+            }
+        }
+        if (sourceStats.isDirectory()) {
+            if (!recursive) {
+                throw new Error(`Source is a directory. Use recursive=true to copy directories.`);
+            }
+            // Create the destination directory if it doesn't exist
+            await ensureDirectoryExists(validDestPath);
+            // Copy directory recursively
+            await copyDir(validSourcePath, validDestPath, allowedDirectories);
+            return `Successfully copied directory ${sourcePath} to ${destinationPath}`;
+        }
+        else {
+            // It's a file, copy it directly
+            await fs.copyFile(validSourcePath, validDestPath);
+            return `Successfully copied file ${sourcePath} to ${destinationPath}`;
+        }
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        throw new Error(`Error copying ${sourcePath} to ${destinationPath}: ${errorMessage}`);
+    }
+}

package/dist/copy_files/helpers.js

@@ -0,0 +1,24 @@
+import fs from "fs/promises";
+import path from "path";
+import { validatePath, ensureDirectoryExists } from "../helpers/path.js";
+export async function copyDir(src, dest, allowedDirectories) {
+    // Create destination if it doesn't exist
+    await ensureDirectoryExists(dest);
+    // Get all files in the source directory
+    const entries = await fs.readdir(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        // Make sure paths are validated
+        await validatePath(srcPath, allowedDirectories);
+        await validatePath(destPath, allowedDirectories);
+        if (entry.isDirectory()) {
+            // Recursively copy subdirectories
+            await copyDir(srcPath, destPath, allowedDirectories);
+        }
+        else {
+            // Copy files
+            await fs.copyFile(srcPath, destPath);
+        }
+    }
+}

package/dist/copy_files/schema.js

@@ -0,0 +1,7 @@
+import { z } from "zod";
+export const CopyFileArgsSchema = z.object({
+    source: z.string(),
+    destination: z.string(),
+    recursive: z.boolean().default(false).describe('Copy directories recursively'),
+    overwrite: z.boolean().default(false).describe('Overwrite destination if it exists'),
+});

package/dist/count_lines/handler.js

@@ -0,0 +1,144 @@
+import fs from "fs/promises";
+import path from "path";
+import { validatePath } from "../helpers/path.js";
+import { minimatch } from "minimatch";
+export async function handleCountLines(filePath, recursive, pattern, filePattern, excludePatterns, ignoreEmptyLines, allowedDirectories) {
+    // Validate the path
+    const validPath = await validatePath(filePath, allowedDirectories);
+    // Create regex for line matching if pattern is provided
+    let regex;
+    if (pattern) {
+        try {
+            regex = new RegExp(pattern);
+        }
+        catch (error) {
+            throw new Error(`Invalid regular expression: ${pattern}`);
+        }
+    }
+    // Get file stats to determine if it's a file or directory
+    const stats = await fs.stat(validPath);
+    let files = [];
+    if (stats.isFile()) {
+        // Count lines in a single file
+        const count = await countLinesInFile(validPath, regex, ignoreEmptyLines);
+        files.push(count);
+    }
+    else if (stats.isDirectory() && recursive) {
+        // Recursively count lines in a directory
+        files = await countLinesInDirectory(validPath, filePattern, excludePatterns, regex, ignoreEmptyLines, allowedDirectories);
+    }
+    else if (stats.isDirectory() && !recursive) {
+        throw new Error(`Path is a directory. Use recursive=true to count lines in all files.`);
+    }
+    else {
+        throw new Error(`Path is neither a file nor a directory.`);
+    }
+    // Format results
+    let output = '';
+    if (files.length === 0) {
+        output = `No files found matching the criteria.`;
+    }
+    else {
+        let totalLines = 0;
+        let totalMatchingLines = 0;
+        output = "Line counts:\n\n";
+        // Sort by line count (descending)
+        files.sort((a, b) => b.count - a.count);
+        for (const file of files) {
+            totalLines += file.count;
+            if (file.matchingCount !== undefined) {
+                totalMatchingLines += file.matchingCount;
+            }
+            if (pattern) {
+                output += `${file.file}: ${file.count} lines total, ${file.matchingCount} matching lines\n`;
+            }
+            else {
+                output += `${file.file}: ${file.count} lines\n`;
+            }
+        }
+        output += "\n";
+        output += `Total: ${files.length} files, ${totalLines} lines`;
+        if (pattern) {
+            output += `, ${totalMatchingLines} matching lines`;
+        }
+    }
+    return output;
+}
+async function countLinesInFile(filePath, regex, ignoreEmptyLines) {
+    // Read file content
+    const content = await fs.readFile(filePath, 'utf-8');
+    // Split into lines
+    const lines = content.split('\n');
+    let count = lines.length;
+    let matchingCount;
+    // Handle empty lines if needed
+    if (ignoreEmptyLines) {
+        count = lines.filter(line => line.trim() !== '').length;
+    }
+    // Count matching lines if regex is provided
+    if (regex) {
+        matchingCount = lines.filter(line => {
+            if (ignoreEmptyLines && line.trim() === '') {
+                return false;
+            }
+            return regex.test(line);
+        }).length;
+    }
+    return {
+        file: filePath,
+        count,
+        matchingCount
+    };
+}
+async function countLinesInDirectory(dirPath, filePattern, excludePatterns, regex, ignoreEmptyLines, allowedDirectories) {
+    const results = [];
+    async function processDirectory(currentPath) {
+        try {
+            const entries = await fs.readdir(currentPath, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(currentPath, entry.name);
+                try {
+                    // Validate each path before processing
+                    await validatePath(fullPath, allowedDirectories);
+                    // Get relative path for glob matching
+                    const relativePath = path.relative(dirPath, fullPath);
+                    // Check if path should be excluded
+                    const shouldExclude = excludePatterns.some(excludePattern => {
+                        return minimatch(relativePath, excludePattern, { dot: true });
+                    });
+                    if (shouldExclude) {
+                        continue;
+                    }
+                    if (entry.isDirectory()) {
+                        // Recursively process subdirectories
+                        await processDirectory(fullPath);
+                    }
+                    else if (entry.isFile()) {
+                        // Check if file matches the file pattern
+                        if (minimatch(entry.name, filePattern, { dot: true }) ||
+                            minimatch(relativePath, filePattern, { dot: true })) {
+                            try {
+                                const count = await countLinesInFile(fullPath, regex, ignoreEmptyLines);
+                                results.push(count);
+                            }
+                            catch (error) {
+                                // Skip files that can't be read as text
+                                continue;
+                            }
+                        }
+                    }
+                }
+                catch (error) {
+                    // Skip invalid paths
+                    continue;
+                }
+            }
+        }
+        catch (error) {
+            // Skip directories we can't read
+            return;
+        }
+    }
+    await processDirectory(dirPath);
+    return results;
+}

package/dist/count_lines/schema.js

@@ -0,0 +1,9 @@
+import { z } from "zod";
+export const CountLinesArgsSchema = z.object({
+    path: z.string().describe("Path to the file or directory to count lines"),
+    recursive: z.boolean().optional().default(false).describe("Whether to recursively count lines in directories"),
+    pattern: z.string().optional().describe("Regex pattern to match lines (only count matching lines)"),
+    filePattern: z.string().optional().default("**").describe("Glob pattern to match files when counting recursively"),
+    excludePatterns: z.array(z.string()).optional().default([]).describe("Glob patterns to exclude"),
+    ignoreEmptyLines: z.boolean().optional().default(false).describe("Whether to ignore empty lines"),
+});

package/dist/create_directories/handler.js

@@ -0,0 +1,29 @@
+import fs from "fs/promises";
+import { validatePath } from "../helpers/path.js";
+export async function handleCreateDirectories(paths, allowedDirectories) {
+    const results = [];
+    const errors = [];
+    await Promise.all(paths.map(async (dirPath) => {
+        try {
+            // Validate path is within allowed directories
+            const validPath = await validatePath(dirPath, allowedDirectories);
+            // Create directory (and parent directories if needed)
+            await fs.mkdir(validPath, { recursive: true });
+            results.push(`Successfully created directory: ${dirPath}`);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            errors.push(`Failed to create directory ${dirPath}: ${errorMessage}`);
+        }
+    }));
+    // Format the results
+    const successCount = results.length;
+    const errorCount = errors.length;
+    let output = `Processed ${successCount + errorCount} directories:\n`;
+    output += `- ${successCount} directories created successfully\n`;
+    if (errorCount > 0) {
+        output += `- ${errorCount} directories failed\n\n`;
+        output += "Errors:\n" + errors.join("\n");
+    }
+    return output;
+}

package/dist/create_directories/schema.js

@@ -0,0 +1,4 @@
+import { z } from "zod";
+export const CreateDirectoriesArgsSchema = z.object({
+    paths: z.array(z.string()).describe("Paths of directories to create"),
+});