@wonderwhy-er/desktop-commander 0.2.3 → 0.2.4

package/dist/tools/filesystem.js

@@ -7,6 +7,77 @@ import { createInterface } from 'readline';
 import { capture } from '../utils/capture.js';
 import { withTimeout } from '../utils/withTimeout.js';
 import { configManager } from '../config-manager.js';
+// CONSTANTS SECTION - Consolidate all timeouts and thresholds
+const FILE_OPERATION_TIMEOUTS = {
+    PATH_VALIDATION: 10000, // 10 seconds
+    URL_FETCH: 30000, // 30 seconds  
+    FILE_READ: 30000, // 30 seconds
+};
+const FILE_SIZE_LIMITS = {
+    LARGE_FILE_THRESHOLD: 10 * 1024 * 1024, // 10MB
+    LINE_COUNT_LIMIT: 10 * 1024 * 1024, // 10MB for line counting
+};
+const READ_PERFORMANCE_THRESHOLDS = {
+    SMALL_READ_THRESHOLD: 100, // For very small reads
+    DEEP_OFFSET_THRESHOLD: 1000, // For byte estimation
+    SAMPLE_SIZE: 10000, // Sample size for estimation
+    CHUNK_SIZE: 8192, // 8KB chunks for reverse reading
+};
+// UTILITY FUNCTIONS - Eliminate duplication
+/**
+ * Count lines in text content efficiently
+ * @param content Text content to count lines in
+ * @returns Number of lines
+ */
+function countLines(content) {
+    return content.split('\n').length;
+}
+/**
+ * Count lines in a file efficiently (for files under size limit)
+ * @param filePath Path to the file
+ * @returns Line count or undefined if file too large/can't read
+ */
+async function getFileLineCount(filePath) {
+    try {
+        const stats = await fs.stat(filePath);
+        // Only count lines for reasonably sized files to avoid performance issues
+        if (stats.size < FILE_SIZE_LIMITS.LINE_COUNT_LIMIT) {
+            const content = await fs.readFile(filePath, 'utf8');
+            return countLines(content);
+        }
+    }
+    catch (error) {
+        // If we can't read the file, just return undefined
+    }
+    return undefined;
+}
+/**
+ * Get MIME type information for a file
+ * @param filePath Path to the file
+ * @returns Object with mimeType and isImage properties
+ */
+async function getMimeTypeInfo(filePath) {
+    const { getMimeType, isImageFile } = await import('./mime-types.js');
+    const mimeType = getMimeType(filePath);
+    const isImage = isImageFile(mimeType);
+    return { mimeType, isImage };
+}
+/**
+ * Get file extension for telemetry purposes
+ * @param filePath Path to the file
+ * @returns Lowercase file extension
+ */
+function getFileExtension(filePath) {
+    return path.extname(filePath).toLowerCase();
+}
+/**
+ * Get default read length from configuration
+ * @returns Default number of lines to read
+ */
+async function getDefaultReadLength() {
+    const config = await configManager.getConfig();
+    return config.fileReadLineLimit ?? 1000; // Default to 1000 lines if not set
+}
 // Initialize allowed directories from configuration
 async function getAllowedDirs() {
     try {
@@ -116,7 +187,6 @@ async function isPathAllowed(pathToCheck) {
  * @throws Error if the path or its parent directories don't exist or if the path is not allowed
  */
 export async function validatePath(requestedPath) {
-    const PATH_VALIDATION_TIMEOUT = 10000; // 10 seconds timeout
     const validationOperation = async () => {
         // Expand home directory if present
         const expandedPath = expandHome(requestedPath);
@@ -150,12 +220,12 @@ export async function validatePath(requestedPath) {
         }
     };
     // Execute with timeout
-    const result = await withTimeout(validationOperation(), PATH_VALIDATION_TIMEOUT, `Path validation operation`, // Generic name for telemetry
+    const result = await withTimeout(validationOperation(), FILE_OPERATION_TIMEOUTS.PATH_VALIDATION, `Path validation operation`, // Generic name for telemetry
     null);
     if (result === null) {
         // Keep original path in error for AI but a generic message for telemetry
         capture('server_path_validation_timeout', {
-            timeoutMs: PATH_VALIDATION_TIMEOUT
+            timeoutMs: FILE_OPERATION_TIMEOUTS.PATH_VALIDATION
         });
         throw new Error(`Path validation failed for path: ${requestedPath}`);
     }
@@ -170,9 +240,8 @@ export async function readFileFromUrl(url) {
     // Import the MIME type utilities
     const { isImageFile } = await import('./mime-types.js');
     // Set up fetch with timeout
-    const FETCH_TIMEOUT_MS = 30000;
     const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+    const timeoutId = setTimeout(() => controller.abort(), FILE_OPERATION_TIMEOUTS.URL_FETCH);
     try {
         const response = await fetch(url, {
             signal: controller.signal
@@ -202,11 +271,52 @@ export async function readFileFromUrl(url) {
         clearTimeout(timeoutId);
         // Return error information instead of throwing
         const errorMessage = error instanceof DOMException && error.name === 'AbortError'
-            ? `URL fetch timed out after ${FETCH_TIMEOUT_MS}ms: ${url}`
+            ? `URL fetch timed out after ${FILE_OPERATION_TIMEOUTS.URL_FETCH}ms: ${url}`
             : `Failed to fetch URL: ${error instanceof Error ? error.message : String(error)}`;
         throw new Error(errorMessage);
     }
 }
+/**
+ * Generate enhanced status message with total and remaining line information
+ * @param readLines Number of lines actually read
+ * @param offset Starting offset (line number)
+ * @param totalLines Total lines in the file (if available)
+ * @param isNegativeOffset Whether this is a tail operation
+ * @returns Enhanced status message string
+ */
+function generateEnhancedStatusMessage(readLines, offset, totalLines, isNegativeOffset = false) {
+    if (isNegativeOffset) {
+        // For tail operations (negative offset)
+        if (totalLines !== undefined) {
+            return `[Reading last ${readLines} lines (total: ${totalLines} lines)]`;
+        }
+        else {
+            return `[Reading last ${readLines} lines]`;
+        }
+    }
+    else {
+        // For normal reads (positive offset)
+        if (totalLines !== undefined) {
+            const endLine = offset + readLines;
+            const remainingLines = Math.max(0, totalLines - endLine);
+            if (offset === 0) {
+                return `[Reading ${readLines} lines from start (total: ${totalLines} lines, ${remainingLines} remaining)]`;
+            }
+            else {
+                return `[Reading ${readLines} lines from line ${offset} (total: ${totalLines} lines, ${remainingLines} remaining)]`;
+            }
+        }
+        else {
+            // Fallback when total lines unknown
+            if (offset === 0) {
+                return `[Reading ${readLines} lines from start]`;
+            }
+            else {
+                return `[Reading ${readLines} lines from line ${offset}]`;
+            }
+        }
+    }
+}
 /**
  * Read file content using smart positioning for optimal performance
  * @param filePath Path to the file (already validated)
@@ -219,34 +329,34 @@ export async function readFileFromUrl(url) {
 async function readFileWithSmartPositioning(filePath, offset, length, mimeType, includeStatusMessage = true) {
     const stats = await fs.stat(filePath);
     const fileSize = stats.size;
-    const LARGE_FILE_THRESHOLD = 10 * 1024 * 1024; // 10MB threshold
-    const SMALL_READ_THRESHOLD = 100; // For very small reads, use efficient methods
+    // Get total line count for enhanced status messages (only for smaller files)
+    const totalLines = await getFileLineCount(filePath);
     // For negative offsets (tail behavior), use reverse reading
     if (offset < 0) {
         const requestedLines = Math.abs(offset);
-        if (fileSize > LARGE_FILE_THRESHOLD && requestedLines <= SMALL_READ_THRESHOLD) {
+        if (fileSize > FILE_SIZE_LIMITS.LARGE_FILE_THRESHOLD && requestedLines <= READ_PERFORMANCE_THRESHOLDS.SMALL_READ_THRESHOLD) {
             // Use efficient reverse reading for large files with small tail requests
-            return await readLastNLinesReverse(filePath, requestedLines, mimeType, includeStatusMessage);
+            return await readLastNLinesReverse(filePath, requestedLines, mimeType, includeStatusMessage, totalLines);
         }
         else {
             // Use readline circular buffer for other cases
-            return await readFromEndWithReadline(filePath, requestedLines, mimeType, includeStatusMessage);
+            return await readFromEndWithReadline(filePath, requestedLines, mimeType, includeStatusMessage, totalLines);
         }
     }
     // For positive offsets
     else {
         // For small files or reading from start, use simple readline
-        if (fileSize < LARGE_FILE_THRESHOLD || offset === 0) {
-            return await readFromStartWithReadline(filePath, offset, length, mimeType, includeStatusMessage);
+        if (fileSize < FILE_SIZE_LIMITS.LARGE_FILE_THRESHOLD || offset === 0) {
+            return await readFromStartWithReadline(filePath, offset, length, mimeType, includeStatusMessage, totalLines);
         }
         // For large files with middle/end reads, try to estimate position
         else {
             // If seeking deep into file, try byte estimation
-            if (offset > 1000) {
-                return await readFromEstimatedPosition(filePath, offset, length, mimeType, includeStatusMessage);
+            if (offset > READ_PERFORMANCE_THRESHOLDS.DEEP_OFFSET_THRESHOLD) {
+                return await readFromEstimatedPosition(filePath, offset, length, mimeType, includeStatusMessage, totalLines);
             }
             else {
-                return await readFromStartWithReadline(filePath, offset, length, mimeType, includeStatusMessage);
+                return await readFromStartWithReadline(filePath, offset, length, mimeType, includeStatusMessage, totalLines);
             }
         }
     }
@@ -254,17 +364,16 @@ async function readFileWithSmartPositioning(filePath, offset, length, mimeType,
 /**
  * Read last N lines efficiently by reading file backwards in chunks
  */
-async function readLastNLinesReverse(filePath, n, mimeType, includeStatusMessage = true) {
+async function readLastNLinesReverse(filePath, n, mimeType, includeStatusMessage = true, fileTotalLines) {
     const fd = await fs.open(filePath, 'r');
     try {
         const stats = await fd.stat();
         const fileSize = stats.size;
-        const chunkSize = 8192; // 8KB chunks
         let position = fileSize;
         let lines = [];
         let partialLine = '';
         while (position > 0 && lines.length < n) {
-            const readSize = Math.min(chunkSize, position);
+            const readSize = Math.min(READ_PERFORMANCE_THRESHOLDS.CHUNK_SIZE, position);
             position -= readSize;
             const buffer = Buffer.alloc(readSize);
             await fd.read(buffer, 0, readSize, position);
@@ -280,7 +389,7 @@ async function readLastNLinesReverse(filePath, n, mimeType, includeStatusMessage
         }
         const result = lines.slice(-n); // Get exactly n lines
         const content = includeStatusMessage
-            ? `[Reading last ${result.length} lines]\n\n${result.join('\n')}`
+            ? `${generateEnhancedStatusMessage(result.length, -n, fileTotalLines, true)}\n\n${result.join('\n')}`
             : result.join('\n');
         return { content, mimeType, isImage: false };
     }
@@ -291,7 +400,7 @@ async function readLastNLinesReverse(filePath, n, mimeType, includeStatusMessage
 /**
  * Read from end using readline with circular buffer
  */
-async function readFromEndWithReadline(filePath, requestedLines, mimeType, includeStatusMessage = true) {
+async function readFromEndWithReadline(filePath, requestedLines, mimeType, includeStatusMessage = true, fileTotalLines) {
     const rl = createInterface({
         input: createReadStream(filePath),
         crlfDelay: Infinity
@@ -317,14 +426,14 @@ async function readFromEndWithReadline(filePath, requestedLines, mimeType, inclu
         result = buffer.slice(0, totalLines);
     }
     const content = includeStatusMessage
-        ? `[Reading last ${result.length} lines]\n\n${result.join('\n')}`
+        ? `${generateEnhancedStatusMessage(result.length, -requestedLines, fileTotalLines, true)}\n\n${result.join('\n')}`
         : result.join('\n');
     return { content, mimeType, isImage: false };
 }
 /**
  * Read from start/middle using readline
  */
-async function readFromStartWithReadline(filePath, offset, length, mimeType, includeStatusMessage = true) {
+async function readFromStartWithReadline(filePath, offset, length, mimeType, includeStatusMessage = true, fileTotalLines) {
     const rl = createInterface({
         input: createReadStream(filePath),
         crlfDelay: Infinity
@@ -341,9 +450,7 @@ async function readFromStartWithReadline(filePath, offset, length, mimeType, inc
     }
     rl.close();
     if (includeStatusMessage) {
-        const statusMessage = offset === 0
-            ? `[Reading ${result.length} lines from start]`
-            : `[Reading ${result.length} lines from line ${offset}]`;
+        const statusMessage = generateEnhancedStatusMessage(result.length, offset, fileTotalLines, false);
         const content = `${statusMessage}\n\n${result.join('\n')}`;
         return { content, mimeType, isImage: false };
     }
@@ -355,7 +462,7 @@ async function readFromStartWithReadline(filePath, offset, length, mimeType, inc
 /**
  * Read from estimated byte position for very large files
  */
-async function readFromEstimatedPosition(filePath, offset, length, mimeType, includeStatusMessage = true) {
+async function readFromEstimatedPosition(filePath, offset, length, mimeType, includeStatusMessage = true, fileTotalLines) {
     // First, do a quick scan to estimate lines per byte
     const rl = createInterface({
         input: createReadStream(filePath),
@@ -363,17 +470,16 @@ async function readFromEstimatedPosition(filePath, offset, length, mimeType, inc
     });
     let sampleLines = 0;
     let bytesRead = 0;
-    const SAMPLE_SIZE = 10000; // Sample first 10KB
     for await (const line of rl) {
         bytesRead += Buffer.byteLength(line, 'utf-8') + 1; // +1 for newline
         sampleLines++;
-        if (bytesRead >= SAMPLE_SIZE)
+        if (bytesRead >= READ_PERFORMANCE_THRESHOLDS.SAMPLE_SIZE)
             break;
     }
     rl.close();
     if (sampleLines === 0) {
         // Fallback to simple read
-        return await readFromStartWithReadline(filePath, offset, length, mimeType, includeStatusMessage);
+        return await readFromStartWithReadline(filePath, offset, length, mimeType, includeStatusMessage, fileTotalLines);
     }
     // Estimate average line length and seek position
     const avgLineLength = bytesRead / sampleLines;
@@ -407,7 +513,7 @@ async function readFromEstimatedPosition(filePath, offset, length, mimeType, inc
         }
         rl2.close();
         const content = includeStatusMessage
-            ? `[Reading ${result.length} lines from estimated position (target line ${offset})]\n\n${result.join('\n')}`
+            ? `${generateEnhancedStatusMessage(result.length, offset, fileTotalLines, false)}\n\n${result.join('\n')}`
             : result.join('\n');
         return { content, mimeType, isImage: false };
     }
@@ -427,16 +533,13 @@ export async function readFileFromDisk(filePath, offset = 0, length) {
     if (!filePath || typeof filePath !== 'string') {
         throw new Error('Invalid file path provided');
     }
-    // Import the MIME type utilities
-    const { getMimeType, isImageFile } = await import('./mime-types.js');
     // Get default length from config if not provided
     if (length === undefined) {
-        const config = await configManager.getConfig();
-        length = config.fileReadLineLimit ?? 1000; // Default to 1000 lines if not set
+        length = await getDefaultReadLength();
     }
     const validPath = await validatePath(filePath);
     // Get file extension for telemetry using path module consistently
-    const fileExtension = path.extname(validPath).toLowerCase();
+    const fileExtension = getFileExtension(validPath);
     // Check file size before attempting to read
     try {
         const stats = await fs.stat(validPath);
@@ -455,9 +558,7 @@ export async function readFileFromDisk(filePath, offset = 0, length) {
         // If we can't stat the file, continue anyway and let the read operation handle errors
     }
     // Detect the MIME type based on file extension
-    const mimeType = getMimeType(validPath);
-    const isImage = isImageFile(mimeType);
-    const FILE_READ_TIMEOUT = 30000; // 30 seconds timeout for file operations
+    const { mimeType, isImage } = await getMimeTypeInfo(validPath);
     // Use withTimeout to handle potential hangs
     const readOperation = async () => {
         if (isImage) {
@@ -481,7 +582,7 @@ export async function readFileFromDisk(filePath, offset = 0, length) {
         }
     };
     // Execute with timeout
-    const result = await withTimeout(readOperation(), FILE_READ_TIMEOUT, `Read file operation for ${filePath}`, null);
+    const result = await withTimeout(readOperation(), FILE_OPERATION_TIMEOUTS.FILE_READ, `Read file operation for ${filePath}`, null);
     if (result == null) {
         // Handles the impossible case where withTimeout resolves to null instead of throwing
         throw new Error('Failed to read the file');
@@ -513,20 +614,17 @@ export async function readFile(filePath, isUrl, offset, length) {
 export async function readFileInternal(filePath, offset = 0, length) {
     // Get default length from config if not provided
     if (length === undefined) {
-        const config = await configManager.getConfig();
-        length = config.fileReadLineLimit ?? 1000;
+        length = await getDefaultReadLength();
     }
     const validPath = await validatePath(filePath);
     // Get file extension and MIME type
-    const fileExtension = path.extname(validPath).toLowerCase();
-    const { getMimeType, isImageFile } = await import('./mime-types.js');
-    const mimeType = getMimeType(validPath);
-    const isImage = isImageFile(mimeType);
+    const fileExtension = getFileExtension(validPath);
+    const { mimeType, isImage } = await getMimeTypeInfo(validPath);
     if (isImage) {
         throw new Error('Cannot read image files as text for internal operations');
     }
     // IMPORTANT: For internal operations (especially edit operations), we must
-    // preserve exact file content including original line endings. 
+    // preserve exact file content including original line endings.
     // We cannot use readline-based reading as it strips line endings.
     // Read entire file content preserving line endings
     const content = await fs.readFile(validPath, 'utf8');
@@ -582,10 +680,10 @@ function splitLinesPreservingEndings(content) {
 export async function writeFile(filePath, content, mode = 'rewrite') {
     const validPath = await validatePath(filePath);
     // Get file extension for telemetry
-    const fileExtension = path.extname(validPath).toLowerCase();
+    const fileExtension = getFileExtension(validPath);
     // Calculate content metrics
     const contentBytes = Buffer.from(content).length;
-    const lineCount = content.split('\n').length;
+    const lineCount = countLines(content);
     // Capture file extension and operation details in telemetry without capturing the file path
     capture('server_write_file', {
         fileExtension: fileExtension,
@@ -698,15 +796,14 @@ export async function getFileInfo(filePath) {
         permissions: stats.mode.toString(8).slice(-3),
     };
     // For text files that aren't too large, also count lines
-    if (stats.isFile() && stats.size < 10 * 1024 * 1024) { // Limit to 10MB files
+    if (stats.isFile() && stats.size < FILE_SIZE_LIMITS.LINE_COUNT_LIMIT) {
         try {
-            // Import the MIME type utilities
-            const { getMimeType, isImageFile } = await import('./mime-types.js');
-            const mimeType = getMimeType(validPath);
+            // Get MIME type information
+            const { mimeType, isImage } = await getMimeTypeInfo(validPath);
             // Only count lines for non-image, likely text files
-            if (!isImageFile(mimeType)) {
+            if (!isImage) {
                 const content = await fs.readFile(validPath, 'utf8');
-                const lineCount = content.split('\n').length;
+                const lineCount = countLines(content);
                 info.lineCount = lineCount;
                 info.lastLine = lineCount - 1; // Zero-indexed last line
                 info.appendPosition = lineCount; // Position to append at end
@@ -719,5 +816,3 @@ export async function getFileInfo(filePath) {
     }
     return info;
 }
-// This function has been replaced with configManager.getConfig()
-// Use get_config tool to retrieve allowedDirectories