@wonderwhy-er/desktop-commander 0.1.38 → 0.2.0

package/README.md

@@ -58,6 +58,10 @@ Execute long-running terminal commands on your computer and manage processes thr
   - Multiple file support
   - Pattern-based replacements
   - vscode-ripgrep based recursive code or text search in folders
+- Comprehensive audit logging:
+  - All tool calls are automatically logged
+  - Log rotation with 10MB size limit
+  - Detailed timestamps and arguments
 
 ## Installation
 First, ensure you've downloaded and installed the [Claude Desktop app](https://claude.ai/download) and you have [npm installed](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm).
@@ -140,24 +144,24 @@ The server provides a comprehensive set of tools organized into several categori
 
 | Category | Tool | Description |
 |----------|------|-------------|
-| **Configuration** | `get_config` | Get the complete server configuration as JSON (includes blockedCommands, defaultShell, allowedDirectories) |
-| | `set_config_value` | Set a specific configuration value by key. Available settings: <br>• `blockedCommands`: Array of shell commands that cannot be executed<br>• `defaultShell`: Shell to use for commands (e.g., bash, zsh, powershell)<br>• `allowedDirectories`: Array of filesystem paths the server can access for file operations (⚠️ terminal commands can still access files outside these directories) |
+| **Configuration** | `get_config` | Get the complete server configuration as JSON (includes blockedCommands, defaultShell, allowedDirectories, fileReadLineLimit, fileWriteLineLimit, telemetryEnabled) |
+| | `set_config_value` | Set a specific configuration value by key. Available settings: <br>• `blockedCommands`: Array of shell commands that cannot be executed<br>• `defaultShell`: Shell to use for commands (e.g., bash, zsh, powershell)<br>• `allowedDirectories`: Array of filesystem paths the server can access for file operations (⚠️ terminal commands can still access files outside these directories)<br>• `fileReadLineLimit`: Maximum lines to read at once (default: 1000)<br>• `fileWriteLineLimit`: Maximum lines to write at once (default: 50)<br>• `telemetryEnabled`: Enable/disable telemetry (boolean) |
 | **Terminal** | `execute_command` | Execute a terminal command with configurable timeout and shell selection |
 | | `read_output` | Read new output from a running terminal session |
 | | `force_terminate` | Force terminate a running terminal session |
 | | `list_sessions` | List all active terminal sessions |
 | | `list_processes` | List all running processes with detailed information |
 | | `kill_process` | Terminate a running process by PID |
-| **Filesystem** | `read_file` | Read contents from local filesystem or URLs (supports text and images) |
+| **Filesystem** | `read_file` | Read contents from local filesystem or URLs with line-based pagination (supports offset and length parameters) |
 | | `read_multiple_files` | Read multiple files simultaneously |
-| | `write_file` | Completely replace file contents (best for large changes) |
+| | `write_file` | Write file contents with options for rewrite or append mode (uses configurable line limits) |
 | | `create_directory` | Create a new directory or ensure it exists |
 | | `list_directory` | Get detailed listing of files and directories |
 | | `move_file` | Move or rename files and directories |
 | | `search_files` | Find files by name using case-insensitive substring matching |
 | | `search_code` | Search for text/code patterns within file contents using ripgrep |
 | | `get_file_info` | Retrieve detailed metadata about a file or directory |
-| **Text Editing** | `edit_block` | Apply surgical text replacements (best for changes <20% of file size) |
+| **Text Editing** | `edit_block` | Apply targeted text replacements with enhanced prompting for smaller edits (includes character-level diff feedback) |
 
 ### Tool Usage Examples
 
@@ -181,6 +185,18 @@ console.log("new message");
 >>>>>>> REPLACE
 ```
 
+### Enhanced Edit Block Features
+
+The `edit_block` tool includes several enhancements for better reliability:
+
+1. **Improved Prompting**: Tool descriptions now emphasize making multiple small, focused edits rather than one large change
+2. **Fuzzy Search Fallback**: When exact matches fail, it performs fuzzy search and provides detailed feedback
+3. **Character-level Diffs**: Shows exactly what's different using `{-removed-}{+added+}` format
+4. **Multiple Occurrence Support**: Can replace multiple instances with `expected_replacements` parameter
+5. **Comprehensive Logging**: All fuzzy searches are logged for analysis and debugging
+
+When a search fails, you'll see detailed information about the closest match found, including similarity percentage, execution time, and character differences. All these details are automatically logged for later analysis using the fuzzy search log tools.
+
 ### URL Support
 - `read_file` can now fetch content from both local files and URLs
 - Example: `read_file` with `isUrl: true` parameter to read from web resources
@@ -189,6 +205,69 @@ console.log("new message");
 - Claude can see and analyze the actual image content
 - Default 30-second timeout for URL requests
 
+## Fuzzy Search Log Analysis (npm scripts)
+
+The fuzzy search logging system includes convenient npm scripts for analyzing logs outside of the MCP environment:
+
+```bash
+# View recent fuzzy search logs
+npm run logs:view -- --count 20
+
+# Analyze patterns and performance
+npm run logs:analyze -- --threshold 0.8
+
+# Export logs to CSV or JSON
+npm run logs:export -- --format json --output analysis.json
+
+# Clear all logs (with confirmation)
+npm run logs:clear
+```
+
+For detailed documentation on these scripts, see [scripts/README.md](scripts/README.md).
+
+## Fuzzy Search Logs
+
+Desktop Commander includes comprehensive logging for fuzzy search operations in the `edit_block` tool. When an exact match isn't found, the system performs a fuzzy search and logs detailed information for analysis.
+
+### What Gets Logged
+
+Every fuzzy search operation logs:
+- **Search and found text**: The text you're looking for vs. what was found
+- **Similarity score**: How close the match is (0-100%)
+- **Execution time**: How long the search took
+- **Character differences**: Detailed diff showing exactly what's different
+- **File metadata**: Extension, search/found text lengths
+- **Character codes**: Specific character codes causing differences
+
+### Log Location
+
+Logs are automatically saved to:
+- **macOS/Linux**: `~/.claude-server-commander-logs/fuzzy-search.log`
+- **Windows**: `%USERPROFILE%\.claude-server-commander-logs\fuzzy-search.log`
+
+### What You'll Learn
+
+The fuzzy search logs help you understand:
+1. **Why exact matches fail**: Common issues like whitespace differences, line endings, or character encoding
+2. **Performance patterns**: How search complexity affects execution time
+3. **File type issues**: Which file extensions commonly have matching problems
+4. **Character encoding problems**: Specific character codes that cause diffs
+
+## Audit Logging
+
+Desktop Commander now includes comprehensive logging for all tool calls:
+
+### What Gets Logged
+- Every tool call is logged with timestamp, tool name, and arguments (sanitized for privacy)
+- Logs are rotated automatically when they reach 10MB in size
+
+### Log Location
+Logs are saved to:
+- **macOS/Linux**: `~/.claude-server-commander/claude_tool_call.log`
+- **Windows**: `%USERPROFILE%\.claude-server-commander\claude_tool_call.log`
+
+This audit trail helps with debugging, security monitoring, and understanding how Claude is interacting with your system.
+
 ## Handling Long-Running Commands
 
 For commands that may take a while:
@@ -297,7 +376,9 @@ This project extends the MCP Filesystem Server to enable:
 Created as part of exploring Claude MCPs: https://youtube.com/live/TlbjFDbl5Us
 
 ## DONE
-- **29-04-2025 Telemetry Opt Out trought configuration** - There is now setting to disable telemetry in config, ask in chat
+- **20-05-2025 v0.1.40 Release** - Added audit logging for all tool calls, improved line-based file operations, enhanced edit_block with better prompting for smaller edits, added explicit telemetry opt-out prompting 
+- **05-05-2025 Fuzzy Search Logging** - Added comprehensive logging system for fuzzy search operations with detailed analysis tools, character-level diffs, and performance metrics to help debug edit_block failures
+- **29-04-2025 Telemetry Opt Out through configuration** - There is now setting to disable telemetry in config, ask in chat
 - **23-04-2025 Enhanced edit functionality** - Improved format, added fuzzy search and multi-occurrence replacements, should fail less and use edit block more often
 - **16-04-2025 Better configurations** - Improved settings for allowed paths, commands and shell environments
 - **14-04-2025 Windows environment fixes** - Resolved issues specific to Windows platforms
@@ -333,11 +414,13 @@ The following features are currently being explored:
     <ul style="list-style-type: none; padding: 0;">
       <li>🌟 <a href="https://github.com/sponsors/wonderwhy-er"><strong>GitHub Sponsors</strong></a> - Recurring support</li>
       <li>☕ <a href="https://www.buymeacoffee.com/wonderwhyer"><strong>Buy Me A Coffee</strong></a> - One-time contributions</li>
+      <li>💖 <a href="https://www.patreon.com/c/EduardsRuzga"><strong>Patreon</strong></a> - Become a patron and support us monthly</li>
       <li>⭐ <a href="https://github.com/wonderwhy-er/DesktopCommanderMCP"><strong>Star on GitHub</strong></a> - Help others discover the project</li>
     </ul>
   </div>
 </div>
 
+
 ### Supporters Hall of Fame
 
 Generous supporters are featured here. Thank you for helping make this project possible!

package/dist/REPLSessionManager.d.ts

@@ -0,0 +1,109 @@
+interface TerminalManager {
+    executeCommand: (command: string, options?: any) => Promise<any>;
+    sendInputToProcess: (pid: number, input: string) => boolean;
+    getNewOutput: (pid: number) => string;
+    terminateProcess: (pid: number) => Promise<boolean>;
+}
+interface SSHOptions {
+    username?: string;
+    port?: number;
+    identity?: string;
+    password?: string;
+    timeout?: number;
+}
+interface ExecuteOptions {
+    timeout?: number;
+    stopOnError?: boolean;
+}
+export declare class REPLSessionManager {
+    private sessions;
+    private terminalManager;
+    private defaultPromptPatterns;
+    constructor(terminalManager: TerminalManager);
+    /**
+     * Create a new SSH session
+     * @param host - SSH host to connect to
+     * @param options - SSH connection options
+     * @returns PID of the created SSH session
+     */
+    createSSHSession(host: string, options?: SSHOptions): Promise<number>;
+    /**
+     * Create a new REPL session for a specific language
+     * @param language - Language for the REPL (python, node, bash)
+     * @param options - Configuration options
+     * @returns PID of the created session
+     */
+    createSession(language: string, options?: any): Promise<number>;
+    /**
+     * Execute code in an existing REPL session
+     * @param pid - Process ID of the REPL session
+     * @param code - Code to execute
+     * @param options - Execution options
+     * @returns Results including output and status
+     */
+    executeCode(pid: number, code: string, options?: ExecuteOptions): Promise<any>;
+    /**
+     * Send input to a REPL process and wait for output with timeout
+     * @param pid - Process ID
+     * @param input - Input to send
+     * @param language - REPL language
+     * @param timeoutMs - Timeout in milliseconds
+     * @returns Result object with output and status
+     */
+    sendAndReadREPL(pid: number, input: string, language: string, timeoutMs?: number): Promise<any>;
+    /**
+     * Handle multi-line code input for different languages
+     * @param pid - Process ID
+     * @param code - Multi-line code
+     * @param language - REPL language
+     * @param timeout - Timeout in milliseconds
+     * @returns Result object
+     */
+    handleMultilineCode(pid: number, code: string, language: string, timeout: number): Promise<any>;
+    /**
+     * Detect if the REPL output is complete and ready for next input
+     * @param output - Current output
+     * @param language - REPL language or session type
+     * @returns Whether output is complete
+     */
+    isOutputComplete(output: string, language: string): boolean;
+    /**
+     * Calculate appropriate timeout based on code complexity
+     * @param code - Code to analyze
+     * @returns Timeout in milliseconds
+     */
+    calculateTimeout(code: string): number;
+    /**
+     * Detect errors in REPL output
+     * @param output - REPL output
+     * @param language - REPL language
+     * @returns Detected error or null
+     */
+    detectErrors(output: string, language: string): string | null;
+    /**
+     * Clean and format REPL output
+     * @param output - Raw output
+     * @param input - Input that was sent
+     * @param language - REPL language
+     * @returns Cleaned output
+     */
+    cleanOutput(output: string, input: string, language: string): string;
+    /**
+     * List all active REPL sessions
+     * @returns List of session objects
+     */
+    listSessions(): Array<any>;
+    /**
+     * Close a specific REPL session
+     * @param pid - Process ID to close
+     * @returns Success status
+     */
+    closeSession(pid: number): Promise<boolean>;
+    /**
+     * Close all idle sessions older than specified time
+     * @param maxIdleMs - Maximum idle time in milliseconds
+     * @returns Number of closed sessions
+     */
+    closeIdleSessions(maxIdleMs?: number): Promise<number>;
+}
+export {};

package/dist/REPLSessionManager.js

@@ -0,0 +1,364 @@
+import * as os from 'os';
+export class REPLSessionManager {
+    constructor(terminalManager) {
+        this.sessions = new Map();
+        this.terminalManager = terminalManager;
+        this.defaultPromptPatterns = {
+            python: /^(>>>|\.\.\.) /m,
+            node: /> $/m,
+            bash: /[\w\d\-_]+@[\w\d\-_]+:.*[$#] $/m,
+            ssh: /[\w\d\-_]+@[\w\d\-_]+:.*[$#] $/m
+        };
+    }
+    /**
+     * Create a new SSH session
+     * @param host - SSH host to connect to
+     * @param options - SSH connection options
+     * @returns PID of the created SSH session
+     */
+    async createSSHSession(host, options = {}) {
+        if (!host) {
+            throw new Error('SSH host is required');
+        }
+        const username = options.username || os.userInfo().username;
+        const port = options.port || 22;
+        let sshCommand = `ssh ${username}@${host}`;
+        // Add optional parameters
+        if (port !== 22) {
+            sshCommand += ` -p ${port}`;
+        }
+        if (options.identity) {
+            sshCommand += ` -i "${options.identity}"`;
+        }
+        // Start the SSH process
+        const result = await this.terminalManager.executeCommand(sshCommand, { timeout: options.timeout || 10000 });
+        if (!result || result.pid <= 0) {
+            throw new Error(`Failed to start SSH session to ${host}`);
+        }
+        // Handle password prompt if needed
+        if (options.password) {
+            // Wait for password prompt
+            let output = "";
+            const startTime = Date.now();
+            const passwordPromptTimeout = 5000;
+            while (Date.now() - startTime < passwordPromptTimeout) {
+                const newOutput = this.terminalManager.getNewOutput(result.pid);
+                if (newOutput && newOutput.length > 0) {
+                    output += newOutput;
+                    if (output.toLowerCase().includes('password:')) {
+                        // Send password
+                        this.terminalManager.sendInputToProcess(result.pid, options.password + '\n');
+                        break;
+                    }
+                }
+                await new Promise(resolve => setTimeout(resolve, 100));
+            }
+        }
+        // Store session info
+        this.sessions.set(result.pid, {
+            type: 'ssh',
+            host,
+            username,
+            pid: result.pid,
+            startTime: Date.now(),
+            lastActivity: Date.now()
+        });
+        return result.pid;
+    }
+    /**
+     * Create a new REPL session for a specific language
+     * @param language - Language for the REPL (python, node, bash)
+     * @param options - Configuration options
+     * @returns PID of the created session
+     */
+    async createSession(language, options = {}) {
+        // Handle SSH sessions separately
+        if (language.toLowerCase() === 'ssh') {
+            return this.createSSHSession(options.host, options);
+        }
+        let command;
+        let args = [];
+        switch (language.toLowerCase()) {
+            case 'python':
+                command = process.platform === 'win32' ? 'python' : 'python3';
+                args = ['-i'];
+                break;
+            case 'node':
+                command = 'node';
+                break;
+            case 'bash':
+                command = process.platform === 'win32' ? 'cmd' : 'bash';
+                break;
+            default:
+                throw new Error(`Unsupported language: ${language}`);
+        }
+        // Start the process
+        const result = await this.terminalManager.executeCommand(command, { args, timeout: options.timeout || 5000 });
+        if (!result || result.pid <= 0) {
+            throw new Error(`Failed to start ${language} REPL`);
+        }
+        // Store session info
+        this.sessions.set(result.pid, {
+            language,
+            pid: result.pid,
+            startTime: Date.now(),
+            lastActivity: Date.now()
+        });
+        return result.pid;
+    }
+    /**
+     * Execute code in an existing REPL session
+     * @param pid - Process ID of the REPL session
+     * @param code - Code to execute
+     * @param options - Execution options
+     * @returns Results including output and status
+     */
+    async executeCode(pid, code, options = {}) {
+        const session = this.sessions.get(pid);
+        if (!session) {
+            throw new Error(`No active session with PID ${pid}`);
+        }
+        // Calculate timeout based on code complexity if not specified
+        const timeout = options.timeout || this.calculateTimeout(code);
+        // Handle multi-line code
+        if (code.includes('\n')) {
+            return this.handleMultilineCode(pid, code, session.language || 'bash', timeout);
+        }
+        else {
+            return this.sendAndReadREPL(pid, code, session.language || 'bash', timeout);
+        }
+    }
+    /**
+     * Send input to a REPL process and wait for output with timeout
+     * @param pid - Process ID
+     * @param input - Input to send
+     * @param language - REPL language
+     * @param timeoutMs - Timeout in milliseconds
+     * @returns Result object with output and status
+     */
+    async sendAndReadREPL(pid, input, language, timeoutMs = 3000) {
+        // Send the input with newline if not already present
+        const inputToSend = input.endsWith('\n') ? input : input + '\n';
+        const success = this.terminalManager.sendInputToProcess(pid, inputToSend);
+        if (!success) {
+            return {
+                success: false,
+                output: null,
+                error: "Failed to send input to process"
+            };
+        }
+        // Wait for output with timeout
+        let output = "";
+        const startTime = Date.now();
+        // Keep checking for output until timeout
+        while (Date.now() - startTime < timeoutMs) {
+            const newOutput = this.terminalManager.getNewOutput(pid);
+            if (newOutput && newOutput.length > 0) {
+                output += newOutput;
+                // Check if output is complete (using prompt detection)
+                if (this.isOutputComplete(output, language)) {
+                    break;
+                }
+            }
+            await new Promise(resolve => setTimeout(resolve, 100));
+        }
+        // Update last activity time
+        if (this.sessions.has(pid)) {
+            const session = this.sessions.get(pid);
+            if (session) {
+                session.lastActivity = Date.now();
+            }
+        }
+        // Check for errors
+        const error = this.detectErrors(output, language);
+        return {
+            success: true,
+            output: this.cleanOutput(output, input, language),
+            timeout: Date.now() - startTime >= timeoutMs,
+            error: error
+        };
+    }
+    /**
+     * Handle multi-line code input for different languages
+     * @param pid - Process ID
+     * @param code - Multi-line code
+     * @param language - REPL language
+     * @param timeout - Timeout in milliseconds
+     * @returns Result object
+     */
+    async handleMultilineCode(pid, code, language, timeout) {
+        const lines = code.split('\n');
+        let isBlock = false;
+        let fullOutput = '';
+        // For Python, we need to handle indentation carefully
+        if (language.toLowerCase() === 'python') {
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                const isLastLine = i === lines.length - 1;
+                // Send line and wait for prompt
+                const result = await this.sendAndReadREPL(pid, line, language, 
+                // If it's the last line and potentially ending a block, wait longer
+                isLastLine && isBlock ? timeout : Math.min(1000, timeout));
+                fullOutput += result.output || '';
+                // Check if we're in a block (Python indentation)
+                if (line.trim() && (line.startsWith(' ') || line.startsWith('\t'))) {
+                    isBlock = true;
+                }
+                else if (line.trim() === '' && isBlock) {
+                    // Empty line ends a block
+                    isBlock = false;
+                }
+                else if (line.trim() && !line.startsWith(' ') && !line.startsWith('\t')) {
+                    // Non-indented, non-empty line
+                    isBlock = false;
+                }
+                // Handle errors early
+                if (result.error) {
+                    return {
+                        success: false,
+                        output: fullOutput,
+                        error: result.error
+                    };
+                }
+            }
+            // Ensure block is closed with empty line if needed
+            if (isBlock) {
+                const finalResult = await this.sendAndReadREPL(pid, '', language, timeout);
+                fullOutput += finalResult.output || '';
+            }
+        }
+        else {
+            // For other languages, send the entire block at once
+            return await this.sendAndReadREPL(pid, code, language, timeout);
+        }
+        return {
+            success: true,
+            output: fullOutput,
+            error: this.detectErrors(fullOutput, language)
+        };
+    }
+    /**
+     * Detect if the REPL output is complete and ready for next input
+     * @param output - Current output
+     * @param language - REPL language or session type
+     * @returns Whether output is complete
+     */
+    isOutputComplete(output, language) {
+        const pattern = this.defaultPromptPatterns[language.toLowerCase()];
+        if (!pattern)
+            return true; // If no pattern, assume complete
+        return pattern.test(output);
+    }
+    /**
+     * Calculate appropriate timeout based on code complexity
+     * @param code - Code to analyze
+     * @returns Timeout in milliseconds
+     */
+    calculateTimeout(code) {
+        // Base timeout
+        let timeout = 2000;
+        // Add time for loops
+        const loopCount = (code.match(/for|while/g) || []).length;
+        timeout += loopCount * 1000;
+        // Add time for imports or requires
+        const importCount = (code.match(/import|require/g) || []).length;
+        timeout += importCount * 2000;
+        // Add time based on code length
+        timeout += Math.min(code.length * 5, 5000);
+        // Cap at reasonable maximum
+        return Math.min(timeout, 30000);
+    }
+    /**
+     * Detect errors in REPL output
+     * @param output - REPL output
+     * @param language - REPL language
+     * @returns Detected error or null
+     */
+    detectErrors(output, language) {
+        const errorPatterns = {
+            python: /\b(Error|Exception|SyntaxError|ValueError|TypeError)\b:.*$/m,
+            node: /\b(Error|SyntaxError|TypeError|ReferenceError)\b:.*$/m,
+            bash: /\b(command not found|No such file or directory)\b/m
+        };
+        const pattern = errorPatterns[language.toLowerCase()];
+        if (!pattern)
+            return null;
+        const match = output.match(pattern);
+        return match ? match[0] : null;
+    }
+    /**
+     * Clean and format REPL output
+     * @param output - Raw output
+     * @param input - Input that was sent
+     * @param language - REPL language
+     * @returns Cleaned output
+     */
+    cleanOutput(output, input, language) {
+        // Remove echoed input if present
+        let cleaned = output;
+        // Remove the input echo that might appear in the output
+        const inputWithoutNewlines = input.replace(/\n/g, '');
+        if (inputWithoutNewlines.length > 0) {
+            cleaned = cleaned.replace(inputWithoutNewlines, '');
+        }
+        // Remove common prompt patterns
+        if (language.toLowerCase() === 'python') {
+            cleaned = cleaned.replace(/^(>>>|\.\.\.) /mg, '');
+        }
+        else if (language.toLowerCase() === 'node') {
+            cleaned = cleaned.replace(/^> /mg, '');
+        }
+        // Trim whitespace
+        cleaned = cleaned.trim();
+        return cleaned;
+    }
+    /**
+     * List all active REPL sessions
+     * @returns List of session objects
+     */
+    listSessions() {
+        const result = [];
+        this.sessions.forEach((session, pid) => {
+            result.push({
+                pid,
+                language: session.language,
+                startTime: session.startTime,
+                lastActivity: session.lastActivity,
+                idleTime: Date.now() - session.lastActivity
+            });
+        });
+        return result;
+    }
+    /**
+     * Close a specific REPL session
+     * @param pid - Process ID to close
+     * @returns Success status
+     */
+    async closeSession(pid) {
+        if (!this.sessions.has(pid)) {
+            return false;
+        }
+        const success = await this.terminalManager.terminateProcess(pid);
+        if (success) {
+            this.sessions.delete(pid);
+        }
+        return success;
+    }
+    /**
+     * Close all idle sessions older than specified time
+     * @param maxIdleMs - Maximum idle time in milliseconds
+     * @returns Number of closed sessions
+     */
+    async closeIdleSessions(maxIdleMs = 30 * 60 * 1000) {
+        let closedCount = 0;
+        for (const [pid, session] of this.sessions.entries()) {
+            const idleTime = Date.now() - session.lastActivity;
+            if (idleTime > maxIdleMs) {
+                const success = await this.closeSession(pid);
+                if (success)
+                    closedCount++;
+            }
+        }
+        return closedCount;
+    }
+}

package/dist/REPLSessionManager.test.d.ts

@@ -0,0 +1 @@
+export {};