@n0zer0d4y/vulcan-file-ops 1.2.13 → 1.3.0

package/dist/utils/lib.js

@@ -5,6 +5,8 @@ import { createTwoFilesPatch } from "diff";
 import { minimatch } from "minimatch";
 import { normalizePath, expandHome } from "./path-utils.js";
 import { isPathWithinAllowedDirectories } from "./path-validation.js";
+import { RegexEvaluationSession, RegexEvaluationError, DEFAULT_GREP_REGEX_FILE_TIMEOUT_MS, DEFAULT_GREP_REGEX_TOTAL_TIMEOUT_MS, } from "./regex-worker.js";
+import { MAX_TEXT_READ_BYTES } from "./limits.js";
 // Global configuration - set by the main module
 let allowedDirectories = [];
 let ignoredFolders = [];
@@ -304,6 +306,12 @@ export async function validatePath(requestedPath, options) {
                 return absolute;
             }
             catch (parentError) {
+                // Only a missing parent is "does not exist"; an access-denied result
+                // (e.g. the parent resolves outside the allowed directories) must keep
+                // its own message instead of being reported as missing.
+                if (!isNotFoundError(parentError)) {
+                    throw parentError;
+                }
                 if (!createParentIfMissing) {
                     throw new Error(`Parent directory does not exist: ${parentDir}`);
                 }
@@ -318,6 +326,161 @@ export async function validatePath(requestedPath, options) {
         throw error;
     }
 }
+// Canonical containment helpers
+//
+// isPathWithinAllowedDirectories() is a purely lexical check. Paths that are
+// handed to something other than Node's fs (e.g. a shell command line) or that
+// are created with mkdir must also be checked after symlink resolution.
+function isNotFoundError(error) {
+    const code = error.code;
+    return code === "ENOENT" || code === "ENOTDIR";
+}
+/**
+ * Lexical normalization first, then realpath of the nearest existing ancestor
+ * with the non-existent remainder re-appended. Matches Win32 and Node fs
+ * semantics, where ".." is collapsed before symlinks are followed.
+ */
+export async function resolveLexicalCanonicalPath(absolutePath) {
+    const resolved = path.resolve(absolutePath);
+    const tail = [];
+    let current = resolved;
+    while (true) {
+        try {
+            const real = await fs.realpath(current);
+            return tail.length > 0 ? path.join(real, ...tail.reverse()) : real;
+        }
+        catch (error) {
+            if (!isNotFoundError(error)) {
+                throw error;
+            }
+            const parent = path.dirname(current);
+            if (parent === current) {
+                return resolved;
+            }
+            tail.push(path.basename(current));
+            current = parent;
+        }
+    }
+}
+/**
+ * Component-by-component resolution that follows symlinks before applying
+ * "..", matching how a POSIX kernel resolves the path a shell passes to it.
+ * On Windows this is stricter than the OS (which collapses ".." first), which
+ * only ever produces extra denials, never extra access.
+ */
+export async function resolvePhysicalCanonicalPath(inputPath, baseDir) {
+    const absolute = path.isAbsolute(inputPath)
+        ? inputPath
+        : `${baseDir}${path.sep}${inputPath}`;
+    const rawRoot = path.parse(absolute).root;
+    const root = path.parse(path.resolve(absolute)).root;
+    const separator = path.sep === "\\" ? /[\\/]+/ : /\/+/;
+    const components = absolute.slice(rawRoot.length).split(separator);
+    let current = root;
+    for (const component of components) {
+        if (!component || component === ".") {
+            continue;
+        }
+        if (component === "..") {
+            current = path.dirname(current);
+            continue;
+        }
+        const next = path.join(current, component);
+        try {
+            current = await fs.realpath(next);
+        }
+        catch (error) {
+            if (!isNotFoundError(error)) {
+                throw error;
+            }
+            current = next;
+        }
+    }
+    return current;
+}
+/**
+ * True only if the path is inside the allowed directories lexically, after
+ * lexical-then-realpath resolution, and after physical resolution. Relative
+ * paths are resolved against baseDir. Any resolution error denies access.
+ */
+export async function isPathCanonicallyAllowed(inputPath, baseDir) {
+    const allowed = getAllowedDirectories();
+    if (allowed.length === 0 || !inputPath || inputPath.includes("\x00")) {
+        return false;
+    }
+    try {
+        const absolute = path.isAbsolute(inputPath)
+            ? path.resolve(inputPath)
+            : path.resolve(baseDir, inputPath);
+        if (!isPathWithinAllowedDirectories(normalizePath(absolute), allowed)) {
+            return false;
+        }
+        const lexical = await resolveLexicalCanonicalPath(absolute);
+        if (!isPathWithinAllowedDirectories(normalizePath(lexical), allowed)) {
+            return false;
+        }
+        const physical = await resolvePhysicalCanonicalPath(inputPath, baseDir);
+        return isPathWithinAllowedDirectories(normalizePath(physical), allowed);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Create a directory (and any missing ancestors) only inside the allowed
+ * directories. Every directory created is re-checked with realpath so a
+ * symlink or junction swapped into the chain cannot redirect creation.
+ * Returns the real path of the directory.
+ */
+export async function ensureDirectoryWithinAllowed(dirPath) {
+    const absolute = path.resolve(expandHome(dirPath));
+    const allowed = getAllowedDirectories();
+    if (!(await isPathCanonicallyAllowed(absolute, process.cwd()))) {
+        throw new Error(`Access denied - path outside allowed directories: ${absolute} not in ${allowed.join(", ")}`);
+    }
+    const missing = [];
+    let current = absolute;
+    while (true) {
+        try {
+            await fs.lstat(current);
+            break;
+        }
+        catch (error) {
+            if (!isNotFoundError(error)) {
+                throw error;
+            }
+            missing.push(current);
+            const parent = path.dirname(current);
+            if (parent === current) {
+                break;
+            }
+            current = parent;
+        }
+    }
+    for (const dir of missing.reverse()) {
+        try {
+            await fs.mkdir(dir);
+        }
+        catch (error) {
+            if (error.code !== "EEXIST") {
+                throw error;
+            }
+        }
+        const realCreated = await fs.realpath(dir);
+        if (!isPathWithinAllowedDirectories(normalizePath(realCreated), getAllowedDirectories())) {
+            throw new Error(`Access denied - directory resolves outside allowed directories: ${realCreated}`);
+        }
+    }
+    const realFinal = await fs.realpath(absolute);
+    if (!isPathWithinAllowedDirectories(normalizePath(realFinal), getAllowedDirectories())) {
+        throw new Error(`Access denied - directory resolves outside allowed directories: ${realFinal}`);
+    }
+    const stats = await fs.stat(realFinal);
+    if (!stats.isDirectory()) {
+        throw new Error(`Path exists and is not a directory: ${absolute}`);
+    }
+    return realFinal;
+}
 // File Operations
 export async function getFileStats(filePath) {
     const stats = await fs.stat(filePath);
@@ -335,10 +498,21 @@ export async function readFileContent(filePath, encoding = "utf-8") {
     return await fs.readFile(filePath, encoding);
 }
 export async function writeFileContent(filePath, content) {
+    await writeFileAtomic(filePath, content);
+}
+/**
+ * Binary counterpart of writeFileContent (PDF/DOCX output) with the same
+ * symlink-safe, atomic write semantics.
+ */
+export async function writeBinaryFileAtomic(filePath, data) {
+    await writeFileAtomic(filePath, data);
+}
+async function writeFileAtomic(filePath, data) {
+    const encoding = typeof data === "string" ? "utf-8" : undefined;
     try {
         // Security: 'wx' flag ensures exclusive creation - fails if file/symlink exists,
         // preventing writes through pre-existing symlinks
-        await fs.writeFile(filePath, content, { encoding: "utf-8", flag: "wx" });
+        await fs.writeFile(filePath, data, { encoding, flag: "wx" });
     }
     catch (error) {
         if (error.code === "EEXIST") {
@@ -347,7 +521,7 @@ export async function writeFileContent(filePath, content) {
             // replace the target file atomically and don't follow symlinks.
             const tempPath = `${filePath}.${randomBytes(16).toString("hex")}.tmp`;
             try {
-                await fs.writeFile(tempPath, content, "utf-8");
+                await fs.writeFile(tempPath, data, { encoding, flag: "wx" });
                 await fs.rename(tempPath, filePath);
             }
             catch (renameError) {
@@ -651,6 +825,17 @@ export async function applyFileEdits(filePath, edits, dryRun = false, matchingSt
     }
     return formattedDiff;
 }
+/**
+ * VFO-15: head/tail/range reads stream the file, but the text they hold
+ * (collected lines plus the current partial line) must stay bounded, e.g.
+ * for a file consisting of one huge line.
+ */
+function assertWithinTextReadLimit(heldChars) {
+    if (heldChars > MAX_TEXT_READ_BYTES) {
+        throw new Error(`Requested lines exceed the ${(MAX_TEXT_READ_BYTES / 1024 / 1024).toFixed(1)} MB ` +
+            `read limit (the file may contain very long lines). Request fewer lines.`);
+    }
+}
 // Memory-efficient implementation to get the last N lines of a file
 export async function tailFile(filePath, numLines) {
     const CHUNK_SIZE = 1024; // Read 1KB at a time
@@ -666,6 +851,10 @@ export async function tailFile(filePath, numLines) {
         let chunk = Buffer.alloc(CHUNK_SIZE);
         let linesFound = 0;
         let remainingText = "";
+        let linesLength = 0;
+        // The newline that ends the last line does not start another (empty)
+        // line, so tail of "a\nb\n" with 1 line is "b", as with POSIX tail.
+        let atFileEnd = true;
         // Read chunks from the end of the file until we have enough lines
         while (position > 0 && linesFound < numLines) {
             const size = Math.min(CHUNK_SIZE, position);
@@ -675,9 +864,22 @@ export async function tailFile(filePath, numLines) {
                 break;
             // Get the chunk as a string and prepend any remaining text from previous iteration
             const readData = chunk.slice(0, bytesRead).toString("utf-8");
+            // VFO-15: bound memory held for one (partial) line plus the output,
+            // and avoid re-splitting an ever-growing line on every chunk.
+            if (position > 0 && !/[\r\n]/.test(readData)) {
+                remainingText = readData + remainingText;
+                assertWithinTextReadLimit(remainingText.length + linesLength);
+                continue;
+            }
             const chunkText = readData + remainingText;
             // Split by newlines and count
             const chunkLines = normalizeLineEndings(chunkText).split("\n");
+            if (atFileEnd) {
+                if (chunkLines.length > 1 && chunkLines[chunkLines.length - 1] === "") {
+                    chunkLines.pop();
+                }
+                atFileEnd = false;
+            }
             // If this isn't the end of the file, the first line is likely incomplete
             // Save it to prepend to the next chunk
             if (position > 0) {
@@ -688,7 +890,9 @@ export async function tailFile(filePath, numLines) {
             for (let i = chunkLines.length - 1; i >= 0 && linesFound < numLines; i--) {
                 lines.unshift(chunkLines[i]);
                 linesFound++;
+                linesLength += chunkLines[i].length + 1;
             }
+            assertWithinTextReadLimit(linesLength + remainingText.length);
         }
         return lines.join("\n");
     }
@@ -703,6 +907,7 @@ export async function headFile(filePath, numLines) {
         const lines = [];
         let buffer = "";
         let bytesRead = 0;
+        let linesLength = 0;
         const chunk = Buffer.alloc(1024); // 1KB buffer
         // Read chunks and count lines until we have enough or reach EOF
         while (lines.length < numLines) {
@@ -710,17 +915,21 @@ export async function headFile(filePath, numLines) {
             if (result.bytesRead === 0)
                 break; // End of file
             bytesRead += result.bytesRead;
-            buffer += chunk.slice(0, result.bytesRead).toString("utf-8");
-            const newLineIndex = buffer.lastIndexOf("\n");
+            const text = chunk.slice(0, result.bytesRead).toString("utf-8");
+            buffer += text;
+            // Only rescan the buffer when the new chunk completes a line.
+            const newLineIndex = text.includes("\n") ? buffer.lastIndexOf("\n") : -1;
             if (newLineIndex !== -1) {
                 const completeLines = buffer.slice(0, newLineIndex).split("\n");
                 buffer = buffer.slice(newLineIndex + 1);
                 for (const line of completeLines) {
                     lines.push(line);
+                    linesLength += line.length + 1;
                     if (lines.length >= numLines)
                         break;
                 }
             }
+            assertWithinTextReadLimit(linesLength + buffer.length);
         }
         // If there is leftover content and we still need lines, add it
         if (buffer.length > 0 && lines.length < numLines) {
@@ -748,6 +957,7 @@ export async function rangeFile(filePath, startLine, endLine) {
         let currentLineNumber = 0;
         let buffer = "";
         let bytesRead = 0;
+        let targetLength = 0;
         const chunk = Buffer.alloc(CHUNK_SIZE);
         // Read file sequentially until we reach the end line
         while (currentLineNumber < endLine) {
@@ -764,7 +974,19 @@ export async function rangeFile(filePath, startLine, endLine) {
                 break;
             }
             bytesRead += result.bytesRead;
-            buffer += chunk.slice(0, result.bytesRead).toString("utf-8");
+            const text = chunk.slice(0, result.bytesRead).toString("utf-8");
+            if (!text.includes("\n")) {
+                if (currentLineNumber + 1 < startLine) {
+                    // Middle of a line before the range: its content is never needed.
+                    buffer = "";
+                }
+                else {
+                    buffer += text;
+                    assertWithinTextReadLimit(targetLength + buffer.length);
+                }
+                continue;
+            }
+            buffer += text;
             // Process complete lines in buffer
             let newLineIndex = buffer.indexOf("\n");
             while (newLineIndex !== -1) {
@@ -774,6 +996,8 @@ export async function rangeFile(filePath, startLine, endLine) {
                 // Check if this line is within our target range
                 if (currentLineNumber >= startLine && currentLineNumber <= endLine) {
                     targetLines.push(line);
+                    targetLength += line.length + 1;
+                    assertWithinTextReadLimit(targetLength);
                 }
                 // Early exit if we've collected all needed lines
                 if (currentLineNumber >= endLine) {
@@ -792,9 +1016,30 @@ export async function rangeFile(filePath, startLine, endLine) {
         await fileHandle.close();
     }
 }
+/**
+ * Maximum length of a grep_files regex pattern. Compiling is cheap, but long
+ * model-supplied patterns only widen the backtracking attack surface (VFO-14).
+ */
+export const MAX_GREP_PATTERN_LENGTH = 1_000;
+/**
+ * Maximum length of a glob pattern handed to minimatch (glob_files pattern,
+ * excludePatterns, grep_files glob). minimatch has had ReDoS advisories; a
+ * length cap is cheap defense in depth.
+ */
+export const MAX_GLOB_PATTERN_LENGTH = 1_000;
+export { DEFAULT_GREP_REGEX_FILE_TIMEOUT_MS, DEFAULT_GREP_REGEX_TOTAL_TIMEOUT_MS };
+function assertGlobPatternLength(value, what) {
+    if (value.length > MAX_GLOB_PATTERN_LENGTH) {
+        throw new Error(`${what} is too long (${value.length} characters); the maximum is ${MAX_GLOB_PATTERN_LENGTH}`);
+    }
+}
 export async function searchFilesWithValidation(rootPath, pattern, allowedDirectories, options = {}) {
     const { excludePatterns = [] } = options;
     const results = [];
+    assertGlobPatternLength(pattern, "Glob pattern");
+    for (const excludePattern of excludePatterns) {
+        assertGlobPatternLength(excludePattern, "Exclude pattern");
+    }
     // Check if pattern requires recursive search (contains ** or has path separators)
     const needsRecursion = pattern.includes("**") || pattern.includes("/") || pattern.includes("\\");
     async function search(currentPath, currentDepth = 0) {
@@ -826,13 +1071,20 @@ export async function searchFilesWithValidation(rootPath, pattern, allowedDirect
     return results;
 }
 export async function grepFilesWithValidation(pattern, searchPath, allowedDirectories, options = {}) {
-    const { caseInsensitive = false, contextBefore = 0, contextAfter = 0, outputMode = "content", headLimit, multiline = false, fileType, globPattern, } = options;
-    // Create regex with appropriate flags (no 'g' flag to avoid stateful matching)
+    const { caseInsensitive = false, contextBefore = 0, contextAfter = 0, outputMode = "content", headLimit, multiline = false, fileType, globPattern, regexFileTimeoutMs, regexTotalTimeoutMs, } = options;
+    if (pattern.length > MAX_GREP_PATTERN_LENGTH) {
+        throw new Error(`Regex pattern is too long (${pattern.length} characters); the maximum is ${MAX_GREP_PATTERN_LENGTH}`);
+    }
+    if (globPattern) {
+        assertGlobPatternLength(globPattern, "Glob pattern");
+    }
+    // Validate the pattern up front with the same flags the line matcher uses
+    // (no 'g' flag to avoid stateful matching). Compiling is cheap; all matching
+    // against file content happens in a time-bounded worker (VFO-14).
     const flags = caseInsensitive ? "i" : "";
     const dotAllFlag = multiline ? "s" : "";
-    let regex;
     try {
-        regex = new RegExp(pattern, flags + dotAllFlag);
+        new RegExp(pattern, flags + dotAllFlag);
     }
     catch (error) {
         throw new Error(`Invalid regex pattern: ${pattern} - ${error instanceof Error ? error.message : String(error)}`);
@@ -848,6 +1100,32 @@ export async function grepFilesWithValidation(pattern, searchPath, allowedDirect
     // Determine if we need to search recursively
     const stats = await fs.stat(searchPath);
     const isDirectory = stats.isDirectory();
+    // One worker per call, reused across files and always terminated below.
+    const regexSession = new RegexEvaluationSession({
+        fileTimeoutMs: regexFileTimeoutMs,
+        totalTimeoutMs: regexTotalTimeoutMs,
+    });
+    function buildMatch(filePath, lines, i) {
+        const match = {
+            file: filePath,
+            line: i + 1,
+            content: lines[i],
+        };
+        // Add context lines if requested
+        if (contextBefore > 0) {
+            match.contextBefore = [];
+            for (let j = Math.max(0, i - contextBefore); j < i; j++) {
+                match.contextBefore.push(lines[j]);
+            }
+        }
+        if (contextAfter > 0) {
+            match.contextAfter = [];
+            for (let j = i + 1; j < Math.min(lines.length, i + 1 + contextAfter); j++) {
+                match.contextAfter.push(lines[j]);
+            }
+        }
+        return match;
+    }
     async function searchFile(filePath) {
         // Validate path against allowed directories
         try {
@@ -866,10 +1144,13 @@ export async function grepFilesWithValidation(pattern, searchPath, allowedDirect
                 }
             }
         }
-        // Apply glob filter
+        // Apply glob filter. Like ripgrep's --glob, a pattern without a slash
+        // (e.g. "*.md") matches the file name at any depth; a pattern with a
+        // slash (e.g. "src/**/*.ts") is matched against the relative path.
         if (globPattern) {
             const relativePath = path.relative(searchPath, filePath);
-            if (!minimatch(relativePath, globPattern, { dot: true })) {
+            const matchBase = !/[\\/]/.test(globPattern);
+            if (!minimatch(relativePath, globPattern, { dot: true, matchBase })) {
                 return; // Skip files that don't match glob
             }
         }
@@ -890,81 +1171,64 @@ export async function grepFilesWithValidation(pattern, searchPath, allowedDirect
             const content = await fs.readFile(filePath, "utf-8");
             let fileMatchCount = 0;
             let fileHasMatch = false;
+            // Matching lines still to be emitted before head_limit is reached in
+            // content mode; lets the worker stop scanning early. Line output is
+            // replayed below exactly as the former in-thread loop produced it.
+            const remainingHead = outputMode === "content" && headLimit
+                ? Math.max(0, headLimit - result.matches.length)
+                : undefined;
             if (multiline) {
-                // For multiline mode, search the entire content
-                const matches = content.match(new RegExp(pattern, flags + "g"));
-                if (matches) {
+                // For multiline mode, search the entire content (global regex without
+                // dotAll), then find which lines match the dotAll regex.
+                const evaluation = await regexSession.evaluate({
+                    content,
+                    pattern,
+                    flags,
+                    multiline: true,
+                    needLines: outputMode === "content",
+                    maxLineMatches: remainingHead,
+                }, filePath);
+                if (evaluation.hasGlobalMatch) {
                     fileHasMatch = true;
-                    fileMatchCount = matches.length;
-                    result.totalMatches += matches.length;
+                    fileMatchCount = evaluation.globalMatchCount;
+                    result.totalMatches += evaluation.globalMatchCount;
                     if (outputMode === "content") {
-                        // For multiline, we'll split by lines and find which lines have matches
                         const lines = normalizeLineEndings(content).split("\n");
-                        for (let i = 0; i < lines.length; i++) {
-                            const line = lines[i];
-                            if (regex.test(line)) {
-                                if (headLimit && result.matches.length >= headLimit) {
-                                    break;
-                                }
-                                const match = {
-                                    file: filePath,
-                                    line: i + 1,
-                                    content: line,
-                                };
-                                // Add context lines if requested
-                                if (contextBefore > 0) {
-                                    match.contextBefore = [];
-                                    for (let j = Math.max(0, i - contextBefore); j < i; j++) {
-                                        match.contextBefore.push(lines[j]);
-                                    }
-                                }
-                                if (contextAfter > 0) {
-                                    match.contextAfter = [];
-                                    for (let j = i + 1; j < Math.min(lines.length, i + 1 + contextAfter); j++) {
-                                        match.contextAfter.push(lines[j]);
-                                    }
-                                }
-                                result.matches.push(match);
+                        for (const i of evaluation.lineIndices) {
+                            if (headLimit && result.matches.length >= headLimit) {
+                                break;
                             }
+                            result.matches.push(buildMatch(filePath, lines, i));
                         }
                     }
                 }
             }
             else {
-                // For single-line mode, search line by line
-                const lines = normalizeLineEndings(content).split("\n");
-                for (let i = 0; i < lines.length; i++) {
-                    const line = lines[i];
-                    if (regex.test(line)) {
-                        fileHasMatch = true;
-                        fileMatchCount++;
-                        result.totalMatches++;
-                        // Handle different output modes
-                        if (outputMode === "content") {
-                            // Check head limit for content mode
-                            if (headLimit && result.matches.length >= headLimit) {
-                                break; // Stop processing this file
-                            }
-                            const match = {
-                                file: filePath,
-                                line: i + 1,
-                                content: line,
-                            };
-                            // Add context lines if requested
-                            if (contextBefore > 0) {
-                                match.contextBefore = [];
-                                for (let j = Math.max(0, i - contextBefore); j < i; j++) {
-                                    match.contextBefore.push(lines[j]);
-                                }
-                            }
-                            if (contextAfter > 0) {
-                                match.contextAfter = [];
-                                for (let j = i + 1; j < Math.min(lines.length, i + 1 + contextAfter); j++) {
-                                    match.contextAfter.push(lines[j]);
-                                }
-                            }
-                            result.matches.push(match);
+                // For single-line mode, search line by line. In content mode the
+                // former loop counted the match that hit head_limit before breaking,
+                // so one extra matching line is requested.
+                const evaluation = await regexSession.evaluate({
+                    content,
+                    pattern,
+                    flags,
+                    multiline: false,
+                    needLines: true,
+                    maxLineMatches: remainingHead === undefined ? undefined : remainingHead + 1,
+                }, filePath);
+                const lines = outputMode === "content"
+                    ? normalizeLineEndings(content).split("\n")
+                    : [];
+                for (const i of evaluation.lineIndices) {
+                    fileHasMatch = true;
+                    fileMatchCount++;
+                    result.totalMatches++;
+                    // Handle different output modes
+                    if (outputMode === "content") {
+                        // Check head limit for content mode
+                        if (headLimit && result.matches.length >= headLimit) {
+                            break; // Stop processing this file
                         }
+                        result.matches.push(buildMatch(filePath, lines, i));
                     }
                 }
             }
@@ -980,6 +1244,10 @@ export async function grepFilesWithValidation(pattern, searchPath, allowedDirect
             }
         }
         catch (error) {
+            // Regex timeouts / worker failures abort the whole search.
+            if (error instanceof RegexEvaluationError) {
+                throw error;
+            }
             // Skip binary files or files we can't read
             return;
         }
@@ -1015,17 +1283,26 @@ export async function grepFilesWithValidation(pattern, searchPath, allowedDirect
                 }
             }
         }
-        catch {
+        catch (error) {
+            // Regex timeouts / worker failures abort the whole search.
+            if (error instanceof RegexEvaluationError) {
+                throw error;
+            }
             // Skip directories we can't read
             return;
         }
     }
     // Execute search
-    if (isDirectory) {
-        await searchDirectory(searchPath);
+    try {
+        if (isDirectory) {
+            await searchDirectory(searchPath);
+        }
+        else {
+            await searchFile(searchPath);
+        }
     }
-    else {
-        await searchFile(searchPath);
+    finally {
+        await regexSession.dispose();
     }
     return result;
 }

package/dist/utils/limits.js

@@ -0,0 +1,47 @@
+/**
+ * Centralized resource limits.
+ *
+ * These caps protect the (single-process, stdio) MCP server from requests that
+ * would otherwise exhaust memory, hang, or crash it. Keep all tunables here so
+ * they are easy to find and adjust.
+ */
+const MB = 1024 * 1024;
+// ---------------------------------------------------------------------------
+// HTML -> PDF / DOCX generation (VFO-13)
+// ---------------------------------------------------------------------------
+/** Maximum decoded size of a single embedded `data:` image in generated PDF/DOCX. */
+export const MAX_EMBEDDED_IMAGE_BYTES = 10 * MB;
+/**
+ * Maximum pixel count of a PNG that the PDF renderer must fully decode
+ * (alpha channel, indexed transparency or interlacing). 16 MP = 4096x4096.
+ */
+export const MAX_DECODED_IMAGE_PIXELS = 16 * 1024 * 1024;
+/** Hard upper bound for rendering one PDF from HTML before the write fails. */
+export const PDF_GENERATION_TIMEOUT_MS = 30_000;
+// ---------------------------------------------------------------------------
+// Read paths (VFO-15)
+// ---------------------------------------------------------------------------
+/**
+ * Maximum size of a plain-text file returned by read_file/read_multiple_files
+ * in "full" mode, and maximum amount of text held in memory by head/tail/range
+ * reads (output plus the current partial line).
+ */
+export const MAX_TEXT_READ_BYTES = 10 * MB;
+/** Maximum size of a single image returned by attach_image. */
+export const MAX_IMAGE_ATTACH_BYTES = 10 * MB;
+/** Maximum combined size of all images in one attach_image call. */
+export const MAX_IMAGE_ATTACH_TOTAL_BYTES = 20 * MB;
+/** Maximum on-disk size of a document (PDF/Office/ODF) passed to a parser. */
+export const MAX_DOCUMENT_FILE_BYTES = 50 * MB;
+// ---------------------------------------------------------------------------
+// ZIP-based documents (.docx .xlsx .pptx .odt .ods .odp) - zip bomb guard
+// ---------------------------------------------------------------------------
+/** Maximum total uncompressed size of all entries. */
+export const ZIP_MAX_TOTAL_UNCOMPRESSED_BYTES = 200 * MB;
+/** Maximum number of entries in the central directory. */
+export const ZIP_MAX_ENTRIES = 10_000;
+/** Maximum compression ratio for an entry larger than ZIP_RATIO_CHECK_MIN_BYTES. */
+export const ZIP_MAX_COMPRESSION_RATIO = 200;
+/** Entries at or below this uncompressed size are exempt from the ratio check. */
+export const ZIP_RATIO_CHECK_MIN_BYTES = 10 * MB;
+//# sourceMappingURL=limits.js.map