@wonderwhy-er/desktop-commander 0.2.2 → 0.2.4

package/dist/tools/filesystem.js

@@ -2,9 +2,82 @@ import fs from "fs/promises";
 import path from "path";
 import os from 'os';
 import fetch from 'cross-fetch';
+import { createReadStream } from 'fs';
+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 {
@@ -114,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);
@@ -148,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}`);
     }
@@ -168,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
@@ -200,11 +271,256 @@ 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)
+ * @param offset Starting line number (negative for tail behavior)
+ * @param length Maximum number of lines to read
+ * @param mimeType MIME type of the file
+ * @param includeStatusMessage Whether to include status headers (default: true)
+ * @returns File result with content
+ */
+async function readFileWithSmartPositioning(filePath, offset, length, mimeType, includeStatusMessage = true) {
+    const stats = await fs.stat(filePath);
+    const fileSize = stats.size;
+    // 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 > 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, totalLines);
+        }
+        else {
+            // Use readline circular buffer for other cases
+            return await readFromEndWithReadline(filePath, requestedLines, mimeType, includeStatusMessage, totalLines);
+        }
+    }
+    // For positive offsets
+    else {
+        // For small files or reading from start, use simple readline
+        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 > READ_PERFORMANCE_THRESHOLDS.DEEP_OFFSET_THRESHOLD) {
+                return await readFromEstimatedPosition(filePath, offset, length, mimeType, includeStatusMessage, totalLines);
+            }
+            else {
+                return await readFromStartWithReadline(filePath, offset, length, mimeType, includeStatusMessage, totalLines);
+            }
+        }
+    }
+}
+/**
+ * Read last N lines efficiently by reading file backwards in chunks
+ */
+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;
+        let position = fileSize;
+        let lines = [];
+        let partialLine = '';
+        while (position > 0 && lines.length < n) {
+            const readSize = Math.min(READ_PERFORMANCE_THRESHOLDS.CHUNK_SIZE, position);
+            position -= readSize;
+            const buffer = Buffer.alloc(readSize);
+            await fd.read(buffer, 0, readSize, position);
+            const chunk = buffer.toString('utf-8');
+            const text = chunk + partialLine;
+            const chunkLines = text.split('\n');
+            partialLine = chunkLines.shift() || '';
+            lines = chunkLines.concat(lines);
+        }
+        // Add the remaining partial line if we reached the beginning
+        if (position === 0 && partialLine) {
+            lines.unshift(partialLine);
+        }
+        const result = lines.slice(-n); // Get exactly n lines
+        const content = includeStatusMessage
+            ? `${generateEnhancedStatusMessage(result.length, -n, fileTotalLines, true)}\n\n${result.join('\n')}`
+            : result.join('\n');
+        return { content, mimeType, isImage: false };
+    }
+    finally {
+        await fd.close();
+    }
+}
+/**
+ * Read from end using readline with circular buffer
+ */
+async function readFromEndWithReadline(filePath, requestedLines, mimeType, includeStatusMessage = true, fileTotalLines) {
+    const rl = createInterface({
+        input: createReadStream(filePath),
+        crlfDelay: Infinity
+    });
+    const buffer = new Array(requestedLines);
+    let bufferIndex = 0;
+    let totalLines = 0;
+    for await (const line of rl) {
+        buffer[bufferIndex] = line;
+        bufferIndex = (bufferIndex + 1) % requestedLines;
+        totalLines++;
+    }
+    rl.close();
+    // Extract lines in correct order
+    let result;
+    if (totalLines >= requestedLines) {
+        result = [
+            ...buffer.slice(bufferIndex),
+            ...buffer.slice(0, bufferIndex)
+        ].filter(line => line !== undefined);
+    }
+    else {
+        result = buffer.slice(0, totalLines);
+    }
+    const content = includeStatusMessage
+        ? `${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, fileTotalLines) {
+    const rl = createInterface({
+        input: createReadStream(filePath),
+        crlfDelay: Infinity
+    });
+    const result = [];
+    let lineNumber = 0;
+    for await (const line of rl) {
+        if (lineNumber >= offset && result.length < length) {
+            result.push(line);
+        }
+        if (result.length >= length)
+            break; // Early exit optimization
+        lineNumber++;
+    }
+    rl.close();
+    if (includeStatusMessage) {
+        const statusMessage = generateEnhancedStatusMessage(result.length, offset, fileTotalLines, false);
+        const content = `${statusMessage}\n\n${result.join('\n')}`;
+        return { content, mimeType, isImage: false };
+    }
+    else {
+        const content = result.join('\n');
+        return { content, mimeType, isImage: false };
+    }
+}
+/**
+ * Read from estimated byte position for very large files
+ */
+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),
+        crlfDelay: Infinity
+    });
+    let sampleLines = 0;
+    let bytesRead = 0;
+    for await (const line of rl) {
+        bytesRead += Buffer.byteLength(line, 'utf-8') + 1; // +1 for newline
+        sampleLines++;
+        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, fileTotalLines);
+    }
+    // Estimate average line length and seek position
+    const avgLineLength = bytesRead / sampleLines;
+    const estimatedBytePosition = Math.floor(offset * avgLineLength);
+    // Create a new stream starting from estimated position
+    const fd = await fs.open(filePath, 'r');
+    try {
+        const stats = await fd.stat();
+        const startPosition = Math.min(estimatedBytePosition, stats.size);
+        const stream = createReadStream(filePath, { start: startPosition });
+        const rl2 = createInterface({
+            input: stream,
+            crlfDelay: Infinity
+        });
+        const result = [];
+        let lineCount = 0;
+        let firstLineSkipped = false;
+        for await (const line of rl2) {
+            // Skip first potentially partial line if we didn't start at beginning
+            if (!firstLineSkipped && startPosition > 0) {
+                firstLineSkipped = true;
+                continue;
+            }
+            if (result.length < length) {
+                result.push(line);
+            }
+            else {
+                break;
+            }
+            lineCount++;
+        }
+        rl2.close();
+        const content = includeStatusMessage
+            ? `${generateEnhancedStatusMessage(result.length, offset, fileTotalLines, false)}\n\n${result.join('\n')}`
+            : result.join('\n');
+        return { content, mimeType, isImage: false };
+    }
+    finally {
+        await fd.close();
+    }
+}
 /**
  * Read file content from the local filesystem
  * @param filePath Path to the file
@@ -217,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);
@@ -245,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) {
@@ -258,42 +569,9 @@ export async function readFileFromDisk(filePath, offset = 0, length) {
             return { content, mimeType, isImage };
         }
         else {
-            // For all other files, try to read as UTF-8 text with line-based offset and length
+            // For all other files, use smart positioning approach
             try {
-                // Read the entire file first
-                const buffer = await fs.readFile(validPath);
-                const fullContent = buffer.toString('utf-8');
-                // Split into lines for line-based access
-                const lines = fullContent.split('\n');
-                const totalLines = lines.length;
-                // Apply line-based offset and length - handle beyond-file-size scenario
-                let startLine = Math.min(offset, totalLines);
-                let endLine = Math.min(startLine + length, totalLines);
-                // If startLine equals totalLines (reading beyond end), adjust to show some content
-                // Only do this if we're not trying to read the whole file
-                if (startLine === totalLines && offset > 0 && length < Number.MAX_SAFE_INTEGER) {
-                    // Show last few lines instead of nothing
-                    const lastLinesCount = Math.min(10, totalLines); // Show last 10 lines or fewer if file is smaller
-                    startLine = Math.max(0, totalLines - lastLinesCount);
-                    endLine = totalLines;
-                }
-                const selectedLines = lines.slice(startLine, endLine);
-                const truncatedContent = selectedLines.join('\n');
-                // Add an informational message if truncated or adjusted
-                let content = truncatedContent;
-                // Only add informational message for normal reads (not when reading entire file)
-                const isEntireFileRead = offset === 0 && length >= Number.MAX_SAFE_INTEGER;
-                if (!isEntireFileRead) {
-                    if (offset >= totalLines && totalLines > 0) {
-                        // Reading beyond end of file case
-                        content = `[NOTICE: Offset ${offset} exceeds file length (${totalLines} lines). Showing last ${endLine - startLine} lines instead.]\n\n${truncatedContent}`;
-                    }
-                    else if (offset > 0 || endLine < totalLines) {
-                        // Normal partial read case
-                        content = `[Reading ${endLine - startLine} lines from line ${startLine} of ${totalLines} total lines]\n\n${truncatedContent}`;
-                    }
-                }
-                return { content, mimeType, isImage };
+                return await readFileWithSmartPositioning(validPath, offset, length, mimeType, true);
             }
             catch (error) {
                 // If UTF-8 reading fails, treat as binary and return base64 but still as text
@@ -304,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');
@@ -324,13 +602,88 @@ export async function readFile(filePath, isUrl, offset, length) {
         ? readFileFromUrl(filePath)
         : readFileFromDisk(filePath, offset, length);
 }
+/**
+ * Read file content without status messages for internal operations
+ * This function preserves exact file content including original line endings,
+ * which is essential for edit operations that need to maintain file formatting.
+ * @param filePath Path to the file
+ * @param offset Starting line number to read from (default: 0)
+ * @param length Maximum number of lines to read (default: from config or 1000)
+ * @returns File content without status headers, with preserved line endings
+ */
+export async function readFileInternal(filePath, offset = 0, length) {
+    // Get default length from config if not provided
+    if (length === undefined) {
+        length = await getDefaultReadLength();
+    }
+    const validPath = await validatePath(filePath);
+    // Get file extension and MIME type
+    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.
+    // 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');
+    // If we need to apply offset/length, do it while preserving line endings
+    if (offset === 0 && length >= Number.MAX_SAFE_INTEGER) {
+        // Most common case for edit operations: read entire file
+        return content;
+    }
+    // Handle offset/length by splitting on line boundaries while preserving line endings
+    const lines = splitLinesPreservingEndings(content);
+    // Apply offset and length
+    const selectedLines = lines.slice(offset, offset + length);
+    // Join back together (this preserves the original line endings)
+    return selectedLines.join('');
+}
+/**
+ * Split text into lines while preserving original line endings with each line
+ * @param content The text content to split
+ * @returns Array of lines, each including its original line ending
+ */
+function splitLinesPreservingEndings(content) {
+    if (!content)
+        return [''];
+    const lines = [];
+    let currentLine = '';
+    for (let i = 0; i < content.length; i++) {
+        const char = content[i];
+        currentLine += char;
+        // Check for line ending patterns
+        if (char === '\n') {
+            // LF or end of CRLF
+            lines.push(currentLine);
+            currentLine = '';
+        }
+        else if (char === '\r') {
+            // Could be CR or start of CRLF
+            if (i + 1 < content.length && content[i + 1] === '\n') {
+                // It's CRLF, include the \n as well
+                currentLine += content[i + 1];
+                i++; // Skip the \n in next iteration
+            }
+            // Either way, we have a complete line
+            lines.push(currentLine);
+            currentLine = '';
+        }
+    }
+    // Handle any remaining content (file not ending with line ending)
+    if (currentLine) {
+        lines.push(currentLine);
+    }
+    return lines;
+}
 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,
@@ -443,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
@@ -464,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

package/dist/tools/improved-process-tools.d.ts

@@ -0,0 +1,24 @@
+import { ServerResult } from '../types.js';
+/**
+ * Start a new process (renamed from execute_command)
+ * Includes early detection of process waiting for input
+ */
+export declare function startProcess(args: unknown): Promise<ServerResult>;
+/**
+ * Read output from a running process (renamed from read_output)
+ * Includes early detection of process waiting for input
+ */
+export declare function readProcessOutput(args: unknown): Promise<ServerResult>;
+/**
+ * Interact with a running process (renamed from send_input)
+ * Automatically detects when process is ready and returns output
+ */
+export declare function interactWithProcess(args: unknown): Promise<ServerResult>;
+/**
+ * Force terminate a process
+ */
+export declare function forceTerminate(args: unknown): Promise<ServerResult>;
+/**
+ * List active sessions
+ */
+export declare function listSessions(): Promise<ServerResult>;