@wonderwhy-er/desktop-commander 0.1.38 → 0.2.0

package/dist/server.js

@@ -3,8 +3,10 @@ import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSche
 import { zodToJsonSchema } from "zod-to-json-schema";
 // Shared constants for tool descriptions
 const PATH_GUIDANCE = `IMPORTANT: Always use absolute paths (starting with '/' or drive letter like 'C:\\') for reliability. Relative paths may fail as they depend on the current working directory. Tilde paths (~/...) might not work in all contexts. Unless the user explicitly asks for relative paths, use absolute paths.`;
+const CMD_PREFIX_DESCRIPTION = `This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.`;
 import { ExecuteCommandArgsSchema, ReadOutputArgsSchema, ForceTerminateArgsSchema, ListSessionsArgsSchema, KillProcessArgsSchema, ReadFileArgsSchema, ReadMultipleFilesArgsSchema, WriteFileArgsSchema, CreateDirectoryArgsSchema, ListDirectoryArgsSchema, MoveFileArgsSchema, SearchFilesArgsSchema, GetFileInfoArgsSchema, SearchCodeArgsSchema, GetConfigArgsSchema, SetConfigValueArgsSchema, ListProcessesArgsSchema, EditBlockArgsSchema, } from './tools/schemas.js';
 import { getConfig, setConfigValue } from './tools/config.js';
+import { trackToolCall } from './utils/trackTools.js';
 import { VERSION } from './version.js';
 import { capture } from "./utils/capture.js";
 console.error("Loading server.ts");
@@ -41,45 +43,58 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                 // Configuration tools
                 {
                     name: "get_config",
-                    description: "Get the complete server configuration as JSON. Config includes fields for: blockedCommands (array of blocked shell commands), defaultShell (shell to use for commands), allowedDirectories (paths the server can access).",
+                    description: `Get the complete server configuration as JSON. Config includes fields for: blockedCommands (array of blocked shell commands), defaultShell (shell to use for commands), allowedDirectories (paths the server can access), fileReadLineLimit (max lines for read_file, default 1000), fileWriteLineLimit (max lines per write_file call, default 50), telemetryEnabled (boolean for telemetry opt-in/out). ${CMD_PREFIX_DESCRIPTION}`,
                     inputSchema: zodToJsonSchema(GetConfigArgsSchema),
                 },
                 {
                     name: "set_config_value",
-                    description: "Set a specific configuration value by key. WARNING: Should be used in a separate chat from file operations and command execution to prevent security issues. Config keys include: blockedCommands (array), defaultShell (string), allowedDirectories (array of paths). IMPORTANT: Setting allowedDirectories to an empty array ([]) allows full access to the entire file system, regardless of the operating system.",
+                    description: `Set a specific configuration value by key. WARNING: Should be used in a separate chat from file operations and command execution to prevent security issues. Config keys include: blockedCommands (array), defaultShell (string), allowedDirectories (array of paths), fileReadLineLimit (number, max lines for read_file), fileWriteLineLimit (number, max lines per write_file call), telemetryEnabled (boolean). IMPORTANT: Setting allowedDirectories to an empty array ([]) allows full access to the entire file system, regardless of the operating system. ${CMD_PREFIX_DESCRIPTION}`,
                     inputSchema: zodToJsonSchema(SetConfigValueArgsSchema),
                 },
                 // Filesystem tools
                 {
                     name: "read_file",
-                    description: `Read the complete contents of a file from the file system or a URL. Prefer this over 'execute_command' with cat/type for viewing files. When reading from the file system, only works within allowed directories. Can fetch content from URLs when isUrl parameter is set to true. Handles text files normally and image files are returned as viewable images. Recognized image types: PNG, JPEG, GIF, WebP. ${PATH_GUIDANCE}`,
+                    description: `Read the contents of a file from the file system or a URL with optional offset and length parameters. Prefer this over 'execute_command' with cat/type for viewing files. Supports partial file reading with 'offset' (start line, default: 0) and 'length' (max lines to read, default: configurable via 'fileReadLineLimit' setting, initially 1000). When reading from the file system, only works within allowed directories. Can fetch content from URLs when isUrl parameter is set to true (URLs are always read in full regardless of offset/length). Handles text files normally and image files are returned as viewable images. Recognized image types: PNG, JPEG, GIF, WebP. ${PATH_GUIDANCE} ${CMD_PREFIX_DESCRIPTION}`,
                     inputSchema: zodToJsonSchema(ReadFileArgsSchema),
                 },
                 {
                     name: "read_multiple_files",
-                    description: `Read the contents of multiple files simultaneously. Each file's content is returned with its path as a reference. Handles text files normally and renders images as viewable content. Recognized image types: PNG, JPEG, GIF, WebP. Failed reads for individual files won't stop the entire operation. Only works within allowed directories. ${PATH_GUIDANCE}`,
+                    description: `Read the contents of multiple files simultaneously. Each file's content is returned with its path as a reference. Handles text files normally and renders images as viewable content. Recognized image types: PNG, JPEG, GIF, WebP. Failed reads for individual files won't stop the entire operation. Only works within allowed directories. ${PATH_GUIDANCE} ${CMD_PREFIX_DESCRIPTION}`,
                     inputSchema: zodToJsonSchema(ReadMultipleFilesArgsSchema),
                 },
                 {
                     name: "write_file",
-                    description: `Completely replace file contents. Best for large changes (>20% of file) or when edit_block fails. Use with caution as it will overwrite existing files. Only works within allowed directories. ${PATH_GUIDANCE}`,
+                    description: `Write or append to file contents with a configurable line limit per call (default: 50 lines). THIS IS A STRICT REQUIREMENT. ANY file with more than the configured limit MUST BE written in chunks or IT WILL FAIL.
+
+                        NEVER attempt to write more than the configured line limit at once.
+
+                        REQUIRED PROCESS FOR LARGE FILES:
+                        1. FIRST → write_file(filePath, firstChunk, {mode: 'rewrite'})
+                        2. THEN → write_file(filePath, secondChunk, {mode: 'append'})
+                        3. THEN → write_file(filePath, thirdChunk, {mode: 'append'})
+                        ... and so on for each chunk
+                        
+                        If asked to continue writing do not restart from beginning, read end of file to see where you stopped and continue from there
+
+                        Files over the line limit (configurable via 'fileWriteLineLimit' setting) WILL BE REJECTED if not broken into chunks as described above.
+                        Only works within allowed directories. ${PATH_GUIDANCE} ${CMD_PREFIX_DESCRIPTION}`,
                     inputSchema: zodToJsonSchema(WriteFileArgsSchema),
                 },
                 {
                     name: "create_directory",
-                    description: `Create a new directory or ensure a directory exists. Can create multiple nested directories in one operation. Only works within allowed directories. ${PATH_GUIDANCE}`,
+                    description: `Create a new directory or ensure a directory exists. Can create multiple nested directories in one operation. Only works within allowed directories. ${PATH_GUIDANCE} ${CMD_PREFIX_DESCRIPTION}`,
                     inputSchema: zodToJsonSchema(CreateDirectoryArgsSchema),
                 },
                 {
                     name: "list_directory",
-                    description: `Get a detailed listing of all files and directories in a specified path. Use this instead of 'execute_command' with ls/dir commands. Results distinguish between files and directories with [FILE] and [DIR] prefixes. Only works within allowed directories. ${PATH_GUIDANCE}`,
+                    description: `Get a detailed listing of all files and directories in a specified path. Use this instead of 'execute_command' with ls/dir commands. Results distinguish between files and directories with [FILE] and [DIR] prefixes. Only works within allowed directories. ${PATH_GUIDANCE} ${CMD_PREFIX_DESCRIPTION}`,
                     inputSchema: zodToJsonSchema(ListDirectoryArgsSchema),
                 },
                 {
                     name: "move_file",
                     description: `Move or rename files and directories. 
                         Can move files between directories and rename them in a single operation. 
-                        Both source and destination must be within allowed directories. ${PATH_GUIDANCE}`,
+                        Both source and destination must be within allowed directories. ${PATH_GUIDANCE} ${CMD_PREFIX_DESCRIPTION}`,
                     inputSchema: zodToJsonSchema(MoveFileArgsSchema),
                 },
                 {
@@ -88,7 +103,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         Use this instead of 'execute_command' with find/dir/ls for locating files.
                         Searches through all subdirectories from the starting path. 
                         Has a default timeout of 30 seconds which can be customized using the timeoutMs parameter. 
-                        Only searches within allowed directories. ${PATH_GUIDANCE}`,
+                        Only searches within allowed directories. ${PATH_GUIDANCE} ${CMD_PREFIX_DESCRIPTION}`,
                     inputSchema: zodToJsonSchema(SearchFilesArgsSchema),
                 },
                 {
@@ -99,14 +114,14 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         Supports regular expressions, file pattern filtering, and context lines. 
                         Has a default timeout of 30 seconds which can be customized. 
                         Only searches within allowed directories. 
-                        ${PATH_GUIDANCE}`,
+                        ${PATH_GUIDANCE} ${CMD_PREFIX_DESCRIPTION}`,
                     inputSchema: zodToJsonSchema(SearchCodeArgsSchema),
                 },
                 {
                     name: "get_file_info",
                     description: `Retrieve detailed metadata about a file or directory including size, creation time, last modified time, 
                         permissions, and type. 
-                        Only works within allowed directories. ${PATH_GUIDANCE}`,
+                        Only works within allowed directories. ${PATH_GUIDANCE} ${CMD_PREFIX_DESCRIPTION}`,
                     inputSchema: zodToJsonSchema(GetFileInfoArgsSchema),
                 },
                 // Note: list_allowed_directories removed - use get_config to check allowedDirectories
@@ -121,8 +136,9 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         To replace multiple occurrences, provide the expected_replacements parameter with the exact number of matches expected. 
                         UNIQUENESS REQUIREMENT: When expected_replacements=1 (default), include the minimal amount of context necessary (typically 1-3 lines) before and after the change point, with exact whitespace and indentation. 
                         When editing multiple sections, make separate edit_block calls for each distinct change rather than one large replacement. 
-                        When a close but non-exact match is found, a character-level diff is shown in the format: common_prefix{-removed-}{+added+}common_suffix to help you identify what's different. 
-                        ${PATH_GUIDANCE}`,
+                        When a close but non-exact match is found, a character-level diff is shown in the format: common_prefix{-removed-}{+added+}common_suffix to help you identify what's different.
+                        Similar to write_file, there is a configurable line limit (fileWriteLineLimit) that warns if the edited file exceeds this limit. If this happens, consider breaking your edits into smaller, more focused changes.
+                        ${PATH_GUIDANCE} ${CMD_PREFIX_DESCRIPTION}`,
                     inputSchema: zodToJsonSchema(EditBlockArgsSchema),
                 },
                 // Terminal tools
@@ -131,32 +147,32 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     description: `Execute a terminal command with timeout. 
                         Command will continue running in background if it doesn't complete within timeout. 
                         NOTE: For file operations, prefer specialized tools like read_file, search_code, list_directory instead of cat, grep, or ls commands.
-                        ${PATH_GUIDANCE}`,
+                        ${PATH_GUIDANCE} ${CMD_PREFIX_DESCRIPTION}`,
                     inputSchema: zodToJsonSchema(ExecuteCommandArgsSchema),
                 },
                 {
                     name: "read_output",
-                    description: "Read new output from a running terminal session.",
+                    description: `Read new output from a running terminal session. ${CMD_PREFIX_DESCRIPTION}`,
                     inputSchema: zodToJsonSchema(ReadOutputArgsSchema),
                 },
                 {
                     name: "force_terminate",
-                    description: "Force terminate a running terminal session.",
+                    description: `Force terminate a running terminal session. ${CMD_PREFIX_DESCRIPTION}`,
                     inputSchema: zodToJsonSchema(ForceTerminateArgsSchema),
                 },
                 {
                     name: "list_sessions",
-                    description: "List all active terminal sessions.",
+                    description: `List all active terminal sessions. ${CMD_PREFIX_DESCRIPTION}`,
                     inputSchema: zodToJsonSchema(ListSessionsArgsSchema),
                 },
                 {
                     name: "list_processes",
-                    description: "List all running processes. Returns process information including PID, command name, CPU usage, and memory usage.",
+                    description: `List all running processes. Returns process information including PID, command name, CPU usage, and memory usage. ${CMD_PREFIX_DESCRIPTION}`,
                     inputSchema: zodToJsonSchema(ListProcessesArgsSchema),
                 },
                 {
                     name: "kill_process",
-                    description: "Terminate a running process by PID. Use with caution as this will forcefully terminate the specified process.",
+                    description: `Terminate a running process by PID. Use with caution as this will forcefully terminate the specified process. ${CMD_PREFIX_DESCRIPTION}`,
                     inputSchema: zodToJsonSchema(KillProcessArgsSchema),
                 },
             ],
@@ -174,6 +190,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         capture('server_call_tool', {
             name
         });
+        // Track tool call
+        trackToolCall(name, args);
         // Using a more structured approach with dedicated handlers
         switch (name) {
             // Config tools

package/dist/setup-claude-server.js

@@ -385,26 +385,6 @@ function updateSetupStep(index, status, error = null) {
     }
 }
 
-try {
-    // Only dependency is node-machine-id
-    const machineIdInitStep = addSetupStep('initialize_machine_id');
-    try {
-        const machineIdModule = await import('node-machine-id');
-        // Get a unique user ID
-        uniqueUserId = machineIdModule.machineIdSync();
-        updateSetupStep(machineIdInitStep, 'completed');
-    } catch (error) {
-        // Fall back to a semi-unique identifier if machine-id is not available
-        uniqueUserId = `${platform()}-${process.env.USER || process.env.USERNAME || 'unknown'}-${Date.now()}`;
-        updateSetupStep(machineIdInitStep, 'fallback', error);
-    }
-} catch (error) {
-    addSetupStep('initialize_machine_id', 'failed', error);
-}
-
-
-
-
 async function execAsync(command) {
     const execStep = addSetupStep(`exec_${command.substring(0, 20)}...`);
     return new Promise((resolve, reject) => {

package/dist/tools/edit.js

@@ -3,11 +3,66 @@ import { recursiveFuzzyIndexOf, getSimilarityRatio } from './fuzzySearch.js';
 import { capture } from '../utils/capture.js';
 import { EditBlockArgsSchema } from "./schemas.js";
 import path from 'path';
+import { detectLineEnding, normalizeLineEndings } from '../utils/lineEndingHandler.js';
+import { configManager } from '../config-manager.js';
+import { fuzzySearchLogger } from '../utils/fuzzySearchLogger.js';
 /**
  * Threshold for fuzzy matching - similarity must be at least this value to be considered
  * (0-1 scale where 1 is perfect match and 0 is completely different)
  */
 const FUZZY_THRESHOLD = 0.7;
+/**
+ * Extract character code data from diff
+ * @param expected The string that was searched for
+ * @param actual The string that was found
+ * @returns Character code statistics
+ */
+function getCharacterCodeData(expected, actual) {
+    // Find common prefix and suffix
+    let prefixLength = 0;
+    const minLength = Math.min(expected.length, actual.length);
+    // Determine common prefix length
+    while (prefixLength < minLength &&
+        expected[prefixLength] === actual[prefixLength]) {
+        prefixLength++;
+    }
+    // Determine common suffix length
+    let suffixLength = 0;
+    while (suffixLength < minLength - prefixLength &&
+        expected[expected.length - 1 - suffixLength] === actual[actual.length - 1 - suffixLength]) {
+        suffixLength++;
+    }
+    // Extract the different parts
+    const expectedDiff = expected.substring(prefixLength, expected.length - suffixLength);
+    const actualDiff = actual.substring(prefixLength, actual.length - suffixLength);
+    // Count unique character codes in the diff
+    const characterCodes = new Map();
+    const fullDiff = expectedDiff + actualDiff;
+    for (let i = 0; i < fullDiff.length; i++) {
+        const charCode = fullDiff.charCodeAt(i);
+        characterCodes.set(charCode, (characterCodes.get(charCode) || 0) + 1);
+    }
+    // Create character codes string report
+    const charCodeReport = [];
+    characterCodes.forEach((count, code) => {
+        // Include character representation for better readability
+        const char = String.fromCharCode(code);
+        // Make special characters more readable
+        const charDisplay = code < 32 || code > 126 ? `\\x${code.toString(16).padStart(2, '0')}` : char;
+        charCodeReport.push(`${code}:${count}[${charDisplay}]`);
+    });
+    // Sort by character code for consistency
+    charCodeReport.sort((a, b) => {
+        const codeA = parseInt(a.split(':')[0]);
+        const codeB = parseInt(b.split(':')[0]);
+        return codeA - codeB;
+    });
+    return {
+        report: charCodeReport.join(','),
+        uniqueCount: characterCodes.size,
+        diffLength: fullDiff.length
+    };
+}
 export async function performSearchReplace(filePath, block, expectedReplacements = 1) {
     // Check for empty search string to prevent infinite loops
     if (block.search === "") {
@@ -23,18 +78,25 @@ export async function performSearchReplace(filePath, block, expectedReplacements
     // Capture file extension in telemetry without capturing the file path
     capture('server_edit_block', { fileExtension: fileExtension });
     // Read file as plain string
-    const { content } = await readFile(filePath);
+    const { content } = await readFile(filePath, false, 0, Number.MAX_SAFE_INTEGER);
     // Make sure content is a string
     if (typeof content !== 'string') {
         throw new Error('Wrong content for file ' + filePath);
     }
+    // Get the line limit from configuration
+    const config = await configManager.getConfig();
+    const MAX_LINES = config.fileWriteLineLimit ?? 50; // Default to 50 if not set
+    // Detect file's line ending style
+    const fileLineEnding = detectLineEnding(content);
+    // Normalize search string to match file's line endings
+    const normalizedSearch = normalizeLineEndings(block.search, fileLineEnding);
     // First try exact match
     let tempContent = content;
     let count = 0;
-    let pos = tempContent.indexOf(block.search);
+    let pos = tempContent.indexOf(normalizedSearch);
     while (pos !== -1) {
         count++;
-        pos = tempContent.indexOf(block.search, pos + 1);
+        pos = tempContent.indexOf(normalizedSearch, pos + 1);
     }
     // If exact match found and count matches expected replacements, proceed with exact replacement
     if (count > 0 && count === expectedReplacements) {
@@ -42,21 +104,32 @@ export async function performSearchReplace(filePath, block, expectedReplacements
         let newContent = content;
         // If we're only replacing one occurrence, replace it directly
         if (expectedReplacements === 1) {
-            const searchIndex = newContent.indexOf(block.search);
+            const searchIndex = newContent.indexOf(normalizedSearch);
             newContent =
                 newContent.substring(0, searchIndex) +
-                    block.replace +
-                    newContent.substring(searchIndex + block.search.length);
+                    normalizeLineEndings(block.replace, fileLineEnding) +
+                    newContent.substring(searchIndex + normalizedSearch.length);
         }
         else {
             // Replace all occurrences using split and join for multiple replacements
-            newContent = newContent.split(block.search).join(block.replace);
+            newContent = newContent.split(normalizedSearch).join(normalizeLineEndings(block.replace, fileLineEnding));
+        }
+        // Check if search or replace text has too many lines
+        const searchLines = block.search.split('\n').length;
+        const replaceLines = block.replace.split('\n').length;
+        const maxLines = Math.max(searchLines, replaceLines);
+        let warningMessage = "";
+        if (maxLines > MAX_LINES) {
+            const problemText = searchLines > replaceLines ? 'search text' : 'replacement text';
+            warningMessage = `\n\nWARNING: The ${problemText} has ${maxLines} lines (maximum: ${MAX_LINES}).
+            
+RECOMMENDATION: For large search/replace operations, consider breaking them into smaller chunks with fewer lines.`;
         }
         await writeFile(filePath, newContent);
         return {
             content: [{
                     type: "text",
-                    text: `Successfully applied ${expectedReplacements} edit${expectedReplacements > 1 ? 's' : ''} to ${filePath}`
+                    text: `Successfully applied ${expectedReplacements} edit${expectedReplacements > 1 ? 's' : ''} to ${filePath}${warningMessage}`
                 }],
         };
     }
@@ -81,19 +154,47 @@ export async function performSearchReplace(filePath, block, expectedReplacements
         const similarity = getSimilarityRatio(block.search, fuzzyResult.value);
         // Calculate execution time in milliseconds
         const executionTime = performance.now() - startTime;
+        // Generate diff and gather character code data
+        const diff = highlightDifferences(block.search, fuzzyResult.value);
+        // Count character codes in diff
+        const characterCodeData = getCharacterCodeData(block.search, fuzzyResult.value);
+        // Create comprehensive log entry
+        const logEntry = {
+            timestamp: new Date(),
+            searchText: block.search,
+            foundText: fuzzyResult.value,
+            similarity: similarity,
+            executionTime: executionTime,
+            exactMatchCount: count,
+            expectedReplacements: expectedReplacements,
+            fuzzyThreshold: FUZZY_THRESHOLD,
+            belowThreshold: similarity < FUZZY_THRESHOLD,
+            diff: diff,
+            searchLength: block.search.length,
+            foundLength: fuzzyResult.value.length,
+            fileExtension: fileExtension,
+            characterCodes: characterCodeData.report,
+            uniqueCharacterCount: characterCodeData.uniqueCount,
+            diffLength: characterCodeData.diffLength
+        };
+        // Log to file
+        await fuzzySearchLogger.log(logEntry);
+        // Combine all fuzzy search data for single capture
+        const fuzzySearchData = {
+            similarity: similarity,
+            execution_time_ms: executionTime,
+            search_length: block.search.length,
+            file_size: content.length,
+            threshold: FUZZY_THRESHOLD,
+            found_text_length: fuzzyResult.value.length,
+            character_codes: characterCodeData.report,
+            unique_character_count: characterCodeData.uniqueCount,
+            total_diff_length: characterCodeData.diffLength
+        };
         // Check if the fuzzy match is "close enough"
         if (similarity >= FUZZY_THRESHOLD) {
-            // Format differences for clearer output
-            const diff = highlightDifferences(block.search, fuzzyResult.value);
-            // Capture the fuzzy search event
-            capture('server_fuzzy_search_performed', {
-                similarity: similarity,
-                execution_time_ms: executionTime,
-                search_length: block.search.length,
-                file_size: content.length,
-                threshold: FUZZY_THRESHOLD,
-                found_text_length: fuzzyResult.value.length
-            });
+            // Capture the fuzzy search event with all data
+            capture('server_fuzzy_search_performed', fuzzySearchData);
             // If we allow fuzzy matches, we would make the replacement here
             // For now, we'll return a detailed message about the fuzzy match
             return {
@@ -101,20 +202,17 @@ export async function performSearchReplace(filePath, block, expectedReplacements
                         type: "text",
                         text: `Exact match not found, but found a similar text with ${Math.round(similarity * 100)}% similarity (found in ${executionTime.toFixed(2)}ms):\n\n` +
                             `Differences:\n${diff}\n\n` +
-                            `To replace this text, use the exact text found in the file.`
-                    }],
+                            `To replace this text, use the exact text found in the file.\n\n` +
+                            `Log entry saved for analysis. Use the following command to check the log:\n` +
+                            `Check log: ${await fuzzySearchLogger.getLogPath()}`
+                    }], // TODO
             };
         }
         else {
             // If the fuzzy match isn't close enough
-            // Still capture the fuzzy search event even for unsuccessful matches
+            // Still capture the fuzzy search event with all data
             capture('server_fuzzy_search_performed', {
-                similarity: similarity,
-                execution_time_ms: executionTime,
-                search_length: block.search.length,
-                file_size: content.length,
-                threshold: FUZZY_THRESHOLD,
-                found_text_length: fuzzyResult.value.length,
+                ...fuzzySearchData,
                 below_threshold: true
             });
             return {
@@ -122,7 +220,9 @@ export async function performSearchReplace(filePath, block, expectedReplacements
                         type: "text",
                         text: `Search content not found in ${filePath}. The closest match was "${fuzzyResult.value}" ` +
                             `with only ${Math.round(similarity * 100)}% similarity, which is below the ${Math.round(FUZZY_THRESHOLD * 100)}% threshold. ` +
-                            `(Fuzzy search completed in ${executionTime.toFixed(2)}ms)`
+                            `(Fuzzy search completed in ${executionTime.toFixed(2)}ms)\n\n` +
+                            `Log entry saved for analysis. Use the following command to check the log:\n` +
+                            `Check log: ${await fuzzySearchLogger.getLogPath()}`
                     }],
             };
         }

package/dist/tools/enhanced-read-output.js

@@ -0,0 +1,69 @@
+import { terminalManager } from '../terminal-manager.js';
+import { ReadOutputArgsSchema } from './schemas.js';
+
+export async function readOutput(args) {
+  const parsed = ReadOutputArgsSchema.safeParse(args);
+  if (!parsed.success) {
+    return {
+      content: [{ type: "text", text: `Error: Invalid arguments for read_output: ${parsed.error}` }],
+      isError: true,
+    };
+  }
+
+  const { pid, timeout_ms = 5000 } = parsed.data;
+  
+  // Check if the process exists
+  const session = terminalManager.getSession(pid);
+  if (!session) {
+    return {
+      content: [{ type: "text", text: `No session found for PID ${pid}` }],
+      isError: true,
+    };
+  }
+
+  // Wait for output with timeout
+  let output = "";
+  let timeoutReached = false;
+  
+  try {
+    // Create a promise that resolves when new output is available or when timeout is reached
+    const outputPromise = new Promise((resolve) => {
+      // Check for initial output
+      const initialOutput = terminalManager.getNewOutput(pid);
+      if (initialOutput && initialOutput.length > 0) {
+        resolve(initialOutput);
+        return;
+      }
+      
+      // Setup an interval to poll for output
+      const interval = setInterval(() => {
+        const newOutput = terminalManager.getNewOutput(pid);
+        if (newOutput && newOutput.length > 0) {
+          clearInterval(interval);
+          resolve(newOutput);
+        }
+      }, 100); // Check every 100ms
+      
+      // Set a timeout to stop waiting
+      setTimeout(() => {
+        clearInterval(interval);
+        timeoutReached = true;
+        resolve(terminalManager.getNewOutput(pid) || "");
+      }, timeout_ms);
+    });
+    
+    output = await outputPromise;
+  } catch (error) {
+    return {
+      content: [{ type: "text", text: `Error reading output: ${error}` }],
+      isError: true,
+    };
+  }
+
+  return {
+    content: [{
+      type: "text",
+      text: output || 'No new output available' + (timeoutReached ? ' (timeout reached)' : '')
+    }],
+  };
+}

package/dist/tools/enhanced-send-input.js

@@ -0,0 +1,111 @@
+import { terminalManager } from '../terminal-manager.js';
+import { SendInputArgsSchema } from './schemas.js';
+import { capture } from "../utils/capture.js";
+
+export async function sendInput(args) {
+  const parsed = SendInputArgsSchema.safeParse(args);
+  if (!parsed.success) {
+    capture('server_send_input_failed', {
+      error: 'Invalid arguments'
+    });
+    return {
+      content: [{ type: "text", text: `Error: Invalid arguments for send_input: ${parsed.error}` }],
+      isError: true,
+    };
+  }
+
+  const { pid, input, timeout_ms = 5000, wait_for_prompt = false } = parsed.data;
+  
+  try {
+    capture('server_send_input', {
+      pid: pid,
+      inputLength: input.length
+    });
+
+    // Try to send input to the process
+    const success = terminalManager.sendInputToProcess(pid, input);
+    
+    if (!success) {
+      return {
+        content: [{ type: "text", text: `Error: Failed to send input to process ${pid}. The process may have exited or doesn't accept input.` }],
+        isError: true,
+      };
+    }
+
+    // If we don't need to wait for output, return immediately
+    if (!wait_for_prompt) {
+      return {
+        content: [{
+          type: "text",
+          text: `Successfully sent input to process ${pid}. Use read_output to get the process response.`
+        }],
+      };
+    }
+
+    // Wait for output with timeout
+    let output = "";
+    let timeoutReached = false;
+    
+    try {
+      // Create a promise that resolves when new output is available or when timeout is reached
+      const outputPromise = new Promise((resolve) => {
+        // Setup an interval to poll for output
+        const interval = setInterval(() => {
+          const newOutput = terminalManager.getNewOutput(pid);
+          
+          if (newOutput && newOutput.length > 0) {
+            output += newOutput;
+            
+            // Check if output contains a prompt pattern (indicating the REPL is ready for more input)
+            const promptPatterns = [/^>\s*$/, /^>>>\s*$/, /^\.{3}\s*$/]; // Common REPL prompts
+            const lines = output.split('\n');
+            const lastLine = lines[lines.length - 1];
+            const hasPrompt = promptPatterns.some(pattern => pattern.test(lastLine.trim()));
+            
+            if (hasPrompt) {
+              clearInterval(interval);
+              resolve(output);
+            }
+          }
+        }, 100); // Check every 100ms
+        
+        // Set a timeout to stop waiting
+        setTimeout(() => {
+          clearInterval(interval);
+          timeoutReached = true;
+          
+          // Get any final output
+          const finalOutput = terminalManager.getNewOutput(pid);
+          if (finalOutput) {
+            output += finalOutput;
+          }
+          
+          resolve(output);
+        }, timeout_ms);
+      });
+      
+      await outputPromise;
+    } catch (error) {
+      return {
+        content: [{ type: "text", text: `Error reading output after sending input: ${error}` }],
+        isError: true,
+      };
+    }
+
+    return {
+      content: [{
+        type: "text",
+        text: `Input sent to process ${pid}.\n\nOutput received:\n${output || '(No output)'}${timeoutReached ? ' (timeout reached)' : ''}`
+      }],
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    capture('server_send_input_error', {
+      error: errorMessage
+    });
+    return {
+      content: [{ type: "text", text: `Error sending input: ${errorMessage}` }],
+      isError: true,
+    };
+  }
+}

package/dist/tools/filesystem.d.ts

@@ -22,19 +22,21 @@ export declare function readFileFromUrl(url: string): Promise<FileResult>;
 /**
  * Read file content from the local filesystem
  * @param filePath Path to the file
- * @param returnMetadata Whether to return metadata with the content
+ * @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 or file result with metadata
  */
-export declare function readFileFromDisk(filePath: string): Promise<FileResult>;
+export declare function readFileFromDisk(filePath: string, offset?: number, length?: number): Promise<FileResult>;
 /**
  * Read a file from either the local filesystem or a URL
  * @param filePath Path to the file or URL
- * @param returnMetadata Whether to return metadata with the content
  * @param isUrl Whether the path is a URL
+ * @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 or file result with metadata
  */
-export declare function readFile(filePath: string, isUrl?: boolean): Promise<FileResult>;
-export declare function writeFile(filePath: string, content: string): Promise<void>;
+export declare function readFile(filePath: string, isUrl?: boolean, offset?: number, length?: number): Promise<FileResult>;
+export declare function writeFile(filePath: string, content: string, mode?: 'rewrite' | 'append'): Promise<void>;
 export interface MultiFileResult {
     path: string;
     content?: string;