@j0hanz/filesystem-context-mcp 1.0.1 → 1.0.2

package/dist/lib/file-operations.js

@@ -5,12 +5,18 @@ import { createReadStream } from 'node:fs';
 import fg from 'fast-glob';
 import { Minimatch } from 'minimatch';
 import safeRegex from 'safe-regex2';
-import { DEFAULT_MAX_DEPTH, DEFAULT_MAX_RESULTS, DEFAULT_TOP_N, DIR_TRAVERSAL_CONCURRENCY, MAX_LINE_CONTENT_LENGTH, MAX_MEDIA_FILE_SIZE, MAX_SEARCHABLE_FILE_SIZE, MAX_TEXT_FILE_SIZE, MIME_TYPES, PARALLEL_CONCURRENCY, REGEX_MATCH_TIMEOUT_MS, } from './constants.js';
+import { DEFAULT_MAX_DEPTH, DEFAULT_MAX_RESULTS, DEFAULT_TOP_N, DIR_TRAVERSAL_CONCURRENCY, getMimeType, MAX_LINE_CONTENT_LENGTH, MAX_MEDIA_FILE_SIZE, MAX_SEARCHABLE_FILE_SIZE, MAX_TEXT_FILE_SIZE, PARALLEL_CONCURRENCY, REGEX_MATCH_TIMEOUT_MS, } from './constants.js';
 import { ErrorCode, McpError } from './errors.js';
 import { getFileType, isHidden, isProbablyBinary, readFile, runWorkQueue, } from './fs-helpers.js';
+import { parseImageDimensions } from './image-parsing.js';
 import { validateExistingPath, validateExistingPathDetailed, } from './path-validation.js';
-function shouldStopBecauseOfTimeout(deadlineMs) {
-    return deadlineMs !== undefined && Date.now() > deadlineMs;
+// Create a matcher function from exclude patterns
+function createExcludeMatcher(excludePatterns) {
+    if (excludePatterns.length === 0) {
+        return () => false;
+    }
+    const matchers = excludePatterns.map((pattern) => new Minimatch(pattern));
+    return (name, relativePath) => matchers.some((m) => m.match(name) || m.match(relativePath));
 }
 async function processInParallel(items, processor, concurrency = PARALLEL_CONCURRENCY) {
     const results = [];
@@ -54,33 +60,22 @@ function countRegexMatches(line, regex, timeoutMs = REGEX_MATCH_TIMEOUT_MS) {
 /**
  * Check if a regex pattern is simple enough to be safe without full ReDoS analysis.
  * This reduces false positives from safe-regex2 for common safe patterns.
- *
- * A pattern is considered "simple safe" if it:
- * - Has no nested quantifiers (e.g., (a+)+ or (a*)*) which are the main ReDoS concern
- * - Has no high repetition counts (e.g., {25} or higher) that safe-regex2 would flag
- *
- * This is a quick heuristic, not a full safety proof.
  */
 function isSimpleSafePattern(pattern) {
     // Patterns with nested quantifiers are the main ReDoS concern
-    // Look for quantifier followed by closing paren then another quantifier
-    // Matches patterns like: (a+)+, (a*)+, (a+)*, (a?)+, (a{2})+
     const nestedQuantifierPattern = /[+*?}]\s*\)\s*[+*?{]/;
     if (nestedQuantifierPattern.test(pattern)) {
-        return false; // Potentially dangerous, needs full check
+        return false;
     }
     // Check for high repetition counts that safe-regex2 would flag (default limit is 25)
-    // Matches {n} or {n,} or {n,m} where n >= 25
     const highRepetitionPattern = /\{(\d+)(?:,\d*)?\}/g;
     let match;
     while ((match = highRepetitionPattern.exec(pattern)) !== null) {
         const count = parseInt(match[1] ?? '0', 10);
         if (count >= 25) {
-            return false; // High repetition count, needs full check
+            return false;
         }
     }
-    // Simple patterns without nested quantifiers or high repetition are generally safe
-    // Examples: "throw new McpError\(", "\bword\b", "foo|bar"
     return true;
 }
 function getPermissions(mode) {
@@ -94,8 +89,7 @@ export async function getFileInfo(filePath) {
     const { requestedPath, resolvedPath, isSymlink } = await validateExistingPathDetailed(filePath);
     const name = path.basename(requestedPath);
     const ext = path.extname(name).toLowerCase();
-    const mimeType = MIME_TYPES[ext] ?? undefined;
-    // If it is a symlink, try to read the link target without following.
+    const mimeType = ext ? getMimeType(ext) : undefined;
     let symlinkTarget;
     if (isSymlink) {
         try {
@@ -105,7 +99,6 @@ export async function getFileInfo(filePath) {
             // Symlink target unreadable
         }
     }
-    // Use stat for size/dates (follows symlinks), but keep type as symlink based on lstat.
     const stats = await fs.stat(resolvedPath);
     return {
         name,
@@ -130,7 +123,7 @@ export async function listDirectory(dirPath, options = {}) {
     let maxDepthReached = 0;
     let truncated = false;
     let skippedInaccessible = 0;
-    let skippedSymlinks = 0;
+    let symlinksNotFollowed = 0;
     const stopIfNeeded = () => {
         if (maxEntries !== undefined && entries.length >= maxEntries) {
             truncated = true;
@@ -164,7 +157,7 @@ export async function listDirectory(dirPath, options = {}) {
             const relativePath = path.relative(validPath, fullPath) || item.name;
             try {
                 if (item.isSymbolicLink()) {
-                    skippedSymlinks++;
+                    symlinksNotFollowed++;
                     const stats = await fs.lstat(fullPath);
                     let symlinkTarget;
                     if (includeSymlinkTargets) {
@@ -224,7 +217,6 @@ export async function listDirectory(dirPath, options = {}) {
                 return { entry };
             }
         });
-        // Count errors from parallel processing as inaccessible
         skippedInaccessible += processingErrors.length;
         for (const { entry, enqueueDir } of processedEntries) {
             if (stopIfNeeded())
@@ -245,7 +237,6 @@ export async function listDirectory(dirPath, options = {}) {
             case 'modified':
                 return (b.modified?.getTime() ?? 0) - (a.modified?.getTime() ?? 0);
             case 'type':
-                // directories first, then by name
                 if (a.type !== b.type) {
                     return a.type === 'directory' ? -1 : 1;
                 }
@@ -265,7 +256,7 @@ export async function listDirectory(dirPath, options = {}) {
             maxDepthReached,
             truncated,
             skippedInaccessible,
-            skippedSymlinks,
+            symlinksNotFollowed,
         },
     };
 }
@@ -311,8 +302,8 @@ export async function searchFiles(basePath, pattern, excludePatterns = [], optio
         dot: true,
         ignore: excludePatterns,
         suppressErrors: true,
-        followSymbolicLinks: false, // Security: never follow symlinks
-        deep: maxDepth, // Limit search depth if specified
+        followSymbolicLinks: false,
+        deep: maxDepth,
     });
     for await (const entry of stream) {
         const matchPath = typeof entry === 'string' ? entry : String(entry);
@@ -354,17 +345,11 @@ export async function searchFiles(basePath, pattern, excludePatterns = [], optio
         },
     };
 }
-// Re-export readFile from fs-helpers so it can be used by tools
 export { readFile };
-/**
- * Read multiple files in parallel.
- * Individual file errors don't fail the entire operation.
- */
 export async function readMultipleFiles(filePaths, options = {}) {
     const { encoding = 'utf-8', maxSize = MAX_TEXT_FILE_SIZE, head, tail, } = options;
     if (filePaths.length === 0)
         return [];
-    // Preserve input order while limiting concurrency to avoid spiky I/O / EMFILE.
     const output = filePaths.map((filePath) => ({ path: filePath }));
     const { results, errors } = await processInParallel(filePaths.map((filePath, index) => ({ filePath, index })), async ({ filePath, index }) => {
         const result = await readFile(filePath, {
@@ -394,17 +379,13 @@ export async function searchContent(basePath, searchPattern, options = {}) {
     const { filePattern = '**/*', excludePatterns = [], caseSensitive = false, maxResults = DEFAULT_MAX_RESULTS, maxFileSize = MAX_SEARCHABLE_FILE_SIZE, maxFilesScanned, timeoutMs, skipBinary = true, contextLines = 0, wholeWord = false, isLiteral = false, } = options;
     const validPath = await validateExistingPath(basePath);
     const deadlineMs = timeoutMs !== undefined ? Date.now() + timeoutMs : undefined;
-    // Build the final pattern
     let finalPattern = searchPattern;
-    // Escape regex special characters if literal mode
     if (isLiteral) {
         finalPattern = finalPattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
     }
-    // Add word boundaries if whole word mode
     if (wholeWord) {
         finalPattern = `\\b${finalPattern}\\b`;
     }
-    // ReDoS protection: skip check for literal or simple patterns
     const needsReDoSCheck = !isLiteral && !isSimpleSafePattern(finalPattern);
     if (needsReDoSCheck && !safeRegex(finalPattern)) {
         throw new McpError(ErrorCode.E_INVALID_PATTERN, `Potentially unsafe regular expression (ReDoS risk): ${searchPattern}. ` +
@@ -422,12 +403,42 @@ export async function searchContent(basePath, searchPattern, options = {}) {
         const message = error instanceof Error ? error.message : String(error);
         throw new McpError(ErrorCode.E_INVALID_PATTERN, `Invalid regular expression: ${finalPattern} (${message})`, basePath, { searchPattern: finalPattern });
     }
+    // Circular buffer to hold context lines before a match
+    class CircularLineBuffer {
+        capacity;
+        buffer;
+        writeIndex = 0;
+        count = 0;
+        constructor(capacity) {
+            this.capacity = capacity;
+            this.buffer = new Array(capacity);
+        }
+        push(line) {
+            this.buffer[this.writeIndex] = line;
+            this.writeIndex = (this.writeIndex + 1) % this.capacity;
+            if (this.count < this.capacity)
+                this.count++;
+        }
+        toArray() {
+            if (this.count === 0)
+                return [];
+            if (this.count < this.capacity) {
+                return this.buffer.slice(0, this.count);
+            }
+            // Buffer is full - return in correct order starting from writeIndex
+            return [
+                ...this.buffer.slice(this.writeIndex),
+                ...this.buffer.slice(0, this.writeIndex),
+            ];
+        }
+    }
     const matches = [];
     let filesScanned = 0;
     let filesMatched = 0;
     let skippedTooLarge = 0;
     let skippedBinary = 0;
     let skippedInaccessible = 0;
+    let linesSkippedDueToRegexTimeout = 0;
     let truncated = false;
     let stoppedReason;
     const stopNow = (reason) => {
@@ -442,11 +453,11 @@ export async function searchContent(basePath, searchPattern, options = {}) {
         dot: false,
         ignore: excludePatterns,
         suppressErrors: true,
-        followSymbolicLinks: false, // Security: never follow symlinks
+        followSymbolicLinks: false,
     });
     for await (const entry of stream) {
         const file = typeof entry === 'string' ? entry : String(entry);
-        if (shouldStopBecauseOfTimeout(deadlineMs)) {
+        if (deadlineMs !== undefined && Date.now() > deadlineMs) {
             stopNow('timeout');
             break;
         }
@@ -491,12 +502,12 @@ export async function searchContent(basePath, searchPattern, options = {}) {
             });
             let fileHadMatches = false;
             let lineNumber = 0;
-            const lineBuffer = [];
+            const lineBuffer = contextLines > 0 ? new CircularLineBuffer(contextLines) : null;
             const pendingMatches = [];
             try {
                 for await (const line of rl) {
                     lineNumber++;
-                    if (shouldStopBecauseOfTimeout(deadlineMs)) {
+                    if (deadlineMs !== undefined && Date.now() > deadlineMs) {
                         stopNow('timeout');
                         break;
                     }
@@ -518,13 +529,10 @@ export async function searchContent(basePath, searchPattern, options = {}) {
                     }
                     const matchCount = countRegexMatches(line, regex);
                     if (matchCount < 0) {
+                        linesSkippedDueToRegexTimeout++;
                         console.error(`[searchContent] Skipping line ${lineNumber} in ${validFile} due to regex timeout`);
-                        // Still add to buffer for context
-                        if (contextLines > 0) {
+                        if (lineBuffer) {
                             lineBuffer.push(trimmedLine);
-                            if (lineBuffer.length > contextLines) {
-                                lineBuffer.shift();
-                            }
                         }
                         continue;
                     }
@@ -536,8 +544,9 @@ export async function searchContent(basePath, searchPattern, options = {}) {
                             content: trimmedLine,
                             matchCount,
                         };
-                        if (contextLines > 0 && lineBuffer.length > 0) {
-                            newMatch.contextBefore = [...lineBuffer];
+                        const contextBefore = lineBuffer?.toArray();
+                        if (contextBefore && contextBefore.length > 0) {
+                            newMatch.contextBefore = contextBefore;
                         }
                         matches.push(newMatch);
                         if (contextLines > 0) {
@@ -547,11 +556,8 @@ export async function searchContent(basePath, searchPattern, options = {}) {
                             });
                         }
                     }
-                    if (contextLines > 0) {
+                    if (lineBuffer) {
                         lineBuffer.push(trimmedLine);
-                        if (lineBuffer.length > contextLines) {
-                            lineBuffer.shift();
-                        }
                     }
                 }
             }
@@ -564,16 +570,11 @@ export async function searchContent(basePath, searchPattern, options = {}) {
             if (stoppedReason !== undefined)
                 break;
         }
-        catch (error) {
+        catch {
             if (handle) {
                 await handle.close().catch(() => { });
             }
             skippedInaccessible++;
-            // Log unexpected errors for debugging
-            const { code } = error;
-            if (code !== 'ENOENT' && code !== 'EACCES' && code !== 'EPERM') {
-                console.error(`[searchContent] Error processing ${file}:`, error);
-            }
         }
     }
     return {
@@ -589,6 +590,7 @@ export async function searchContent(basePath, searchPattern, options = {}) {
             skippedTooLarge,
             skippedBinary,
             skippedInaccessible,
+            linesSkippedDueToRegexTimeout,
             stoppedReason,
         },
     };
@@ -601,18 +603,11 @@ export async function analyzeDirectory(dirPath, options = {}) {
     let totalSize = 0;
     let currentMaxDepth = 0;
     let skippedInaccessible = 0;
-    let skippedSymlinks = 0;
+    let symlinksNotFollowed = 0;
     const fileTypes = {};
     const largestFiles = [];
     const recentlyModified = [];
-    const excludeMatchers = excludePatterns.length > 0
-        ? excludePatterns.map((pattern) => new Minimatch(pattern))
-        : [];
-    const shouldExclude = (name, relativePath) => {
-        if (excludeMatchers.length === 0)
-            return false;
-        return excludeMatchers.some((m) => m.match(name) || m.match(relativePath));
-    };
+    const shouldExclude = createExcludeMatcher(excludePatterns);
     const insertSorted = (arr, item, compare, maxLen) => {
         if (maxLen <= 0)
             return;
@@ -646,18 +641,16 @@ export async function analyzeDirectory(dirPath, options = {}) {
         for (const item of items) {
             const fullPath = path.join(currentPath, item.name);
             const relativePath = path.relative(validPath, fullPath);
-            // Skip hidden files/directories unless includeHidden is true
             if (!includeHidden && isHidden(item.name)) {
                 continue;
             }
-            // Skip items matching exclude patterns
             if (shouldExclude(item.name, relativePath)) {
                 continue;
             }
             try {
                 const validated = await validateExistingPathDetailed(fullPath);
                 if (validated.isSymlink || item.isSymbolicLink()) {
-                    skippedSymlinks++;
+                    symlinksNotFollowed++;
                     continue;
                 }
                 const stats = await fs.stat(validated.resolvedPath);
@@ -683,7 +676,7 @@ export async function analyzeDirectory(dirPath, options = {}) {
                 if (error instanceof McpError &&
                     (error.code === ErrorCode.E_ACCESS_DENIED ||
                         error.code === ErrorCode.E_SYMLINK_NOT_ALLOWED)) {
-                    skippedSymlinks++;
+                    symlinksNotFollowed++;
                 }
                 else {
                     skippedInaccessible++;
@@ -706,18 +699,13 @@ export async function analyzeDirectory(dirPath, options = {}) {
         summary: {
             truncated: false,
             skippedInaccessible,
-            skippedSymlinks,
+            symlinksNotFollowed,
         },
     };
 }
-/**
- * Build a JSON tree structure of a directory.
- * More efficient for AI parsing than flat file lists.
- */
 export async function getDirectoryTree(dirPath, options = {}) {
     const { maxDepth = DEFAULT_MAX_DEPTH, excludePatterns = [], includeHidden = false, includeSize = false, maxFiles, } = options;
     const validPath = await validateExistingPath(dirPath);
-    // Ensure the requested path is a directory (not just an existing path).
     const rootStats = await fs.stat(validPath);
     if (!rootStats.isDirectory()) {
         throw new McpError(ErrorCode.E_NOT_DIRECTORY, `Not a directory: ${dirPath}`, dirPath);
@@ -726,19 +714,12 @@ export async function getDirectoryTree(dirPath, options = {}) {
     let totalDirectories = 0;
     let maxDepthReached = 0;
     let skippedInaccessible = 0;
-    let skippedSymlinks = 0;
+    let symlinksNotFollowed = 0;
     let truncated = false;
-    const excludeMatchers = excludePatterns.length > 0
-        ? excludePatterns.map((pattern) => new Minimatch(pattern))
-        : [];
+    const shouldExclude = createExcludeMatcher(excludePatterns);
     const hitMaxFiles = () => {
         return maxFiles !== undefined && totalFiles >= maxFiles;
     };
-    const shouldExclude = (name, relativePath) => {
-        if (excludeMatchers.length === 0)
-            return false;
-        return excludeMatchers.some((m) => m.match(name) || m.match(relativePath));
-    };
     const buildTree = async (currentPath, depth, relativePath = '') => {
         if (hitMaxFiles()) {
             truncated = true;
@@ -754,7 +735,7 @@ export async function getDirectoryTree(dirPath, options = {}) {
             if (error instanceof McpError &&
                 (error.code === ErrorCode.E_ACCESS_DENIED ||
                     error.code === ErrorCode.E_SYMLINK_NOT_ALLOWED)) {
-                skippedSymlinks++;
+                symlinksNotFollowed++;
             }
             else {
                 skippedInaccessible++;
@@ -762,7 +743,6 @@ export async function getDirectoryTree(dirPath, options = {}) {
             return null;
         }
         const name = path.basename(currentPath);
-        // Check exclusions
         if (shouldExclude(name, relativePath)) {
             return null;
         }
@@ -771,7 +751,7 @@ export async function getDirectoryTree(dirPath, options = {}) {
         }
         maxDepthReached = Math.max(maxDepthReached, depth);
         if (isSymlink) {
-            skippedSymlinks++;
+            symlinksNotFollowed++;
             return null;
         }
         let stats;
@@ -847,14 +827,10 @@ export async function getDirectoryTree(dirPath, options = {}) {
             maxDepthReached,
             truncated,
             skippedInaccessible,
-            skippedSymlinks,
+            symlinksNotFollowed,
         },
     };
 }
-/**
- * Read a media/binary file and return as base64.
- * Useful for images, audio, and other binary content.
- */
 export async function readMediaFile(filePath, options = {}) {
     const { maxSize = MAX_MEDIA_FILE_SIZE } = options;
     const validPath = await validateExistingPath(filePath);
@@ -867,7 +843,7 @@ export async function readMediaFile(filePath, options = {}) {
         throw new McpError(ErrorCode.E_TOO_LARGE, `File too large: ${size} bytes (max: ${maxSize} bytes)`, filePath, { size, maxSize });
     }
     const ext = path.extname(validPath).toLowerCase();
-    const mimeType = MIME_TYPES[ext] ?? 'application/octet-stream';
+    const mimeType = getMimeType(ext);
     const buffer = await fs.readFile(validPath);
     const data = buffer.toString('base64');
     let width;
@@ -887,117 +863,4 @@ export async function readMediaFile(filePath, options = {}) {
         height,
     };
 }
-const PNG_SIGNATURE = [0x89, 0x50, 0x4e, 0x47];
-const JPEG_SIGNATURE = [0xff, 0xd8];
-const GIF_SIGNATURE = [0x47, 0x49, 0x46];
-const BMP_SIGNATURE = [0x42, 0x4d];
-const WEBP_RIFF = [0x52, 0x49, 0x46, 0x46];
-const WEBP_MARKER = [0x57, 0x45, 0x42, 0x50];
-function matchesSignature(buffer, signature, offset = 0) {
-    if (buffer.length < offset + signature.length)
-        return false;
-    return signature.every((byte, i) => buffer[offset + i] === byte);
-}
-function parsePng(buffer) {
-    if (buffer.length < 24 || !matchesSignature(buffer, PNG_SIGNATURE))
-        return null;
-    return { width: buffer.readUInt32BE(16), height: buffer.readUInt32BE(20) };
-}
-function parseJpeg(buffer) {
-    if (buffer.length < 2 || !matchesSignature(buffer, JPEG_SIGNATURE))
-        return null;
-    let offset = 2;
-    while (offset < buffer.length - 8) {
-        if (buffer[offset] !== 0xff) {
-            offset++;
-            continue;
-        }
-        const marker = buffer[offset + 1];
-        const isSOF = marker !== undefined &&
-            ((marker >= 0xc0 && marker <= 0xc3) ||
-                (marker >= 0xc5 && marker <= 0xc7) ||
-                (marker >= 0xc9 && marker <= 0xcb) ||
-                (marker >= 0xcd && marker <= 0xcf));
-        if (isSOF) {
-            return {
-                width: buffer.readUInt16BE(offset + 7),
-                height: buffer.readUInt16BE(offset + 5),
-            };
-        }
-        if (offset + 3 >= buffer.length)
-            break;
-        offset += 2 + buffer.readUInt16BE(offset + 2);
-    }
-    return null;
-}
-function parseGif(buffer) {
-    if (buffer.length < 10 || !matchesSignature(buffer, GIF_SIGNATURE))
-        return null;
-    return { width: buffer.readUInt16LE(6), height: buffer.readUInt16LE(8) };
-}
-function parseBmp(buffer) {
-    if (buffer.length < 26 || !matchesSignature(buffer, BMP_SIGNATURE))
-        return null;
-    return {
-        width: buffer.readInt32LE(18),
-        height: Math.abs(buffer.readInt32LE(22)),
-    };
-}
-function parseWebp(buffer) {
-    if (buffer.length < 30)
-        return null;
-    if (!matchesSignature(buffer, WEBP_RIFF) ||
-        !matchesSignature(buffer, WEBP_MARKER, 8))
-        return null;
-    const chunkType = [buffer[12], buffer[13], buffer[14], buffer[15]];
-    // VP8 (lossy): 0x56 0x50 0x38 0x20
-    if (chunkType[0] === 0x56 &&
-        chunkType[1] === 0x50 &&
-        chunkType[2] === 0x38 &&
-        chunkType[3] === 0x20) {
-        return {
-            width: buffer.readUInt16LE(26) & 0x3fff,
-            height: buffer.readUInt16LE(28) & 0x3fff,
-        };
-    }
-    // VP8L (lossless): 0x56 0x50 0x38 0x4c
-    if (chunkType[0] === 0x56 &&
-        chunkType[1] === 0x50 &&
-        chunkType[2] === 0x38 &&
-        chunkType[3] === 0x4c) {
-        const bits = buffer.readUInt32LE(21);
-        return { width: (bits & 0x3fff) + 1, height: ((bits >> 14) & 0x3fff) + 1 };
-    }
-    // VP8X (extended): 0x56 0x50 0x38 0x58
-    if (chunkType[0] === 0x56 &&
-        chunkType[1] === 0x50 &&
-        chunkType[2] === 0x38 &&
-        chunkType[3] === 0x58) {
-        const width = (buffer[24] ?? 0) | ((buffer[25] ?? 0) << 8) | ((buffer[26] ?? 0) << 16);
-        const height = (buffer[27] ?? 0) | ((buffer[28] ?? 0) << 8) | ((buffer[29] ?? 0) << 16);
-        return { width: width + 1, height: height + 1 };
-    }
-    return null;
-}
-const IMAGE_PARSERS = {
-    '.png': parsePng,
-    '.jpg': parseJpeg,
-    '.jpeg': parseJpeg,
-    '.gif': parseGif,
-    '.bmp': parseBmp,
-    '.webp': parseWebp,
-};
-/**
- * Parse image dimensions from common image format headers.
- * Supports PNG, JPEG, GIF, BMP, and WebP.
- */
-function parseImageDimensions(buffer, ext) {
-    try {
-        const parser = IMAGE_PARSERS[ext];
-        return parser ? parser(buffer) : null;
-    }
-    catch {
-        return null;
-    }
-}
 //# sourceMappingURL=file-operations.js.map