@wonderwhy-er/desktop-commander 0.1.37 → 0.1.39

package/dist/tools/edit.js

@@ -3,11 +3,64 @@ 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';
 /**
  * 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 === "") {
@@ -28,13 +81,17 @@ export async function performSearchReplace(filePath, block, expectedReplacements
     if (typeof content !== 'string') {
         throw new Error('Wrong content for file ' + filePath);
     }
+    // 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,15 +99,15 @@ 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));
         }
         await writeFile(filePath, newContent);
         return {
@@ -81,19 +138,26 @@ 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);
+        // 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 {
@@ -107,14 +171,9 @@ export async function performSearchReplace(filePath, block, expectedReplacements
         }
         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 {

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.js

@@ -256,7 +256,8 @@ export async function readFileFromDisk(filePath) {
         else {
             // For all other files, try to read as UTF-8 text
             try {
-                const content = await fs.readFile(validPath, "utf-8");
+                const buffer = await fs.readFile(validPath);
+                const content = buffer.toString('utf-8');
                 return { content, mimeType, isImage };
             }
             catch (error) {
@@ -293,7 +294,7 @@ export async function writeFile(filePath, content) {
     const fileExtension = path.extname(validPath).toLowerCase();
     // Capture file extension in telemetry without capturing the file path
     capture('server_write_file', { fileExtension: fileExtension });
-    await fs.writeFile(validPath, content, "utf-8");
+    await fs.writeFile(validPath, content);
 }
 export async function readMultipleFiles(paths) {
     return Promise.all(paths.map(async (filePath) => {
@@ -339,9 +340,9 @@ export async function searchFiles(rootPath, pattern) {
         }
         catch (error) {
             // Only sanitize for telemetry, not for the returned error
-            capture('server_search_files_error', {
+            capture('server_search_read_dir_error', {
                 errorType: error instanceof Error ? error.name : 'Unknown',
-                errorMessage: 'Error reading directory',
+                error: 'Error reading directory',
                 isReadDirError: true
             });
             return; // Skip this directory on error
@@ -377,7 +378,7 @@ export async function searchFiles(rootPath, pattern) {
         // For telemetry only - sanitize error info
         capture('server_search_files_error', {
             errorType: error instanceof Error ? error.name : 'Unknown',
-            errorMessage: 'Error with root path',
+            error: 'Error with root path',
             isRootPathError: true
         });
         // Re-throw the original error for the caller

package/dist/tools/repl.d.ts

@@ -0,0 +1,21 @@
+import { ServerResult } from '../types.js';
+/**
+ * Create a new REPL session
+ */
+export declare function createREPLSession(args: unknown): Promise<ServerResult>;
+/**
+ * Execute code in a REPL session
+ */
+export declare function executeREPLCode(args: unknown): Promise<ServerResult>;
+/**
+ * Terminate a REPL session
+ */
+export declare function terminateREPLSession(args: unknown): Promise<ServerResult>;
+/**
+ * List all active REPL sessions
+ */
+export declare function listREPLSessions(args: unknown): Promise<ServerResult>;
+/**
+ * Get information about a specific REPL session
+ */
+export declare function getREPLSessionInfo(args: unknown): Promise<ServerResult>;

package/dist/tools/repl.js

@@ -0,0 +1,217 @@
+import { replManager } from '../repl-manager.js';
+import { capture } from '../utils/capture.js';
+import { CreateREPLSessionArgsSchema, ExecuteREPLCodeArgsSchema, TerminateREPLSessionArgsSchema, ListREPLSessionsArgsSchema, GetREPLSessionInfoArgsSchema } from './schemas.js';
+/**
+ * Create a new REPL session
+ */
+export async function createREPLSession(args) {
+    const parsed = CreateREPLSessionArgsSchema.safeParse(args);
+    if (!parsed.success) {
+        capture('server_create_repl_session_failed', {
+            error: 'Invalid arguments'
+        });
+        return {
+            content: [{ type: "text", text: `Error: Invalid arguments for create_repl_session: ${parsed.error}` }],
+            isError: true,
+        };
+    }
+    try {
+        const pid = await replManager.createSession(parsed.data.language, parsed.data.timeout);
+        return {
+            content: [{
+                    type: "text",
+                    text: `Successfully created ${parsed.data.language} REPL session with PID ${pid}`
+                }],
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        capture('server_create_repl_session_error', {
+            error: errorMessage
+        });
+        return {
+            content: [{ type: "text", text: `Error creating REPL session: ${errorMessage}` }],
+            isError: true,
+        };
+    }
+}
+/**
+ * Execute code in a REPL session
+ */
+export async function executeREPLCode(args) {
+    const parsed = ExecuteREPLCodeArgsSchema.safeParse(args);
+    if (!parsed.success) {
+        capture('server_execute_repl_code_failed', {
+            error: 'Invalid arguments'
+        });
+        return {
+            content: [{ type: "text", text: `Error: Invalid arguments for execute_repl_code: ${parsed.error}` }],
+            isError: true,
+        };
+    }
+    try {
+        const result = await replManager.executeCode(parsed.data.pid, parsed.data.code, {
+            timeout: parsed.data.timeout,
+            waitForPrompt: parsed.data.waitForPrompt,
+            ignoreErrors: parsed.data.ignoreErrors,
+            multiline: parsed.data.multiline
+        });
+        if (!result.success) {
+            return {
+                content: [{
+                        type: "text",
+                        text: result.error
+                            ? `Error executing code: ${result.error}`
+                            : `Failed to execute code in REPL session ${parsed.data.pid}` +
+                                (result.timeout ? ` (timed out)` : '') +
+                                (result.output ? `\nOutput received: ${result.output}` : '')
+                    }],
+                isError: true,
+            };
+        }
+        return {
+            content: [{
+                    type: "text",
+                    text: `Code executed in REPL session ${parsed.data.pid}` +
+                        (result.timeout ? ` (timed out, partial output below)` : '') +
+                        `\n\nOutput:\n${result.output || '(No output)'}`
+                }],
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        capture('server_execute_repl_code_error', {
+            error: errorMessage
+        });
+        return {
+            content: [{ type: "text", text: `Error executing REPL code: ${errorMessage}` }],
+            isError: true,
+        };
+    }
+}
+/**
+ * Terminate a REPL session
+ */
+export async function terminateREPLSession(args) {
+    const parsed = TerminateREPLSessionArgsSchema.safeParse(args);
+    if (!parsed.success) {
+        capture('server_terminate_repl_session_failed', {
+            error: 'Invalid arguments'
+        });
+        return {
+            content: [{ type: "text", text: `Error: Invalid arguments for terminate_repl_session: ${parsed.error}` }],
+            isError: true,
+        };
+    }
+    try {
+        const success = await replManager.terminateSession(parsed.data.pid);
+        if (!success) {
+            return {
+                content: [{ type: "text", text: `Failed to terminate REPL session ${parsed.data.pid}. The session may have already ended.` }],
+                isError: true,
+            };
+        }
+        return {
+            content: [{
+                    type: "text",
+                    text: `Successfully terminated REPL session ${parsed.data.pid}`
+                }],
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        capture('server_terminate_repl_session_error', {
+            error: errorMessage
+        });
+        return {
+            content: [{ type: "text", text: `Error terminating REPL session: ${errorMessage}` }],
+            isError: true,
+        };
+    }
+}
+/**
+ * List all active REPL sessions
+ */
+export async function listREPLSessions(args) {
+    const parsed = ListREPLSessionsArgsSchema.safeParse(args);
+    if (!parsed.success) {
+        capture('server_list_repl_sessions_failed', {
+            error: 'Invalid arguments'
+        });
+        return {
+            content: [{ type: "text", text: `Error: Invalid arguments for list_repl_sessions: ${parsed.error}` }],
+            isError: true,
+        };
+    }
+    try {
+        const sessions = replManager.listSessions();
+        if (sessions.length === 0) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `No active REPL sessions found`
+                    }],
+            };
+        }
+        const sessionsText = sessions.map(s => `PID: ${s.pid}, Language: ${s.language}, Runtime: ${Math.round(s.runtime / 1000)}s`).join('\n');
+        return {
+            content: [{
+                    type: "text",
+                    text: `Active REPL sessions:\n${sessionsText}`
+                }],
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        capture('server_list_repl_sessions_error', {
+            error: errorMessage
+        });
+        return {
+            content: [{ type: "text", text: `Error listing REPL sessions: ${errorMessage}` }],
+            isError: true,
+        };
+    }
+}
+/**
+ * Get information about a specific REPL session
+ */
+export async function getREPLSessionInfo(args) {
+    const parsed = GetREPLSessionInfoArgsSchema.safeParse(args);
+    if (!parsed.success) {
+        capture('server_get_repl_session_info_failed', {
+            error: 'Invalid arguments'
+        });
+        return {
+            content: [{ type: "text", text: `Error: Invalid arguments for get_repl_session_info: ${parsed.error}` }],
+            isError: true,
+        };
+    }
+    try {
+        const info = replManager.getSessionInfo(parsed.data.pid);
+        if (!info) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `No active REPL session found with PID ${parsed.data.pid}`
+                    }],
+                isError: true,
+            };
+        }
+        return {
+            content: [{
+                    type: "text",
+                    text: `REPL Session ${parsed.data.pid}:\nLanguage: ${info.language}\nRuntime: ${Math.round(info.runtime / 1000)}s`
+                }],
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        capture('server_get_repl_session_info_error', {
+            error: errorMessage
+        });
+        return {
+            content: [{ type: "text", text: `Error getting REPL session info: ${errorMessage}` }],
+            isError: true,
+        };
+    }
+}

package/dist/tools/send-input.d.ts

@@ -0,0 +1,2 @@
+import { ServerResult } from '../types.js';
+export declare function sendInput(args: unknown): Promise<ServerResult>;

package/dist/tools/send-input.js

@@ -0,0 +1,45 @@
+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,
+        };
+    }
+    try {
+        capture('server_send_input', {
+            pid: parsed.data.pid,
+            inputLength: parsed.data.input.length
+        });
+        // Try to send input to the process
+        const success = terminalManager.sendInputToProcess(parsed.data.pid, parsed.data.input);
+        if (!success) {
+            return {
+                content: [{ type: "text", text: `Error: Failed to send input to process ${parsed.data.pid}. The process may have exited or doesn't accept input.` }],
+                isError: true,
+            };
+        }
+        return {
+            content: [{
+                    type: "text",
+                    text: `Successfully sent input to process ${parsed.data.pid}. Use read_output to get the process response.`
+                }],
+        };
+    }
+    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,
+        };
+    }
+}