@wonderwhy-er/desktop-commander 0.2.6 → 0.2.7

package/dist/index-dxt.js

@@ -1,76 +1,39 @@
 #!/usr/bin/env node
-// Add immediate logging before any imports
-console.error("[DXT] === ENTRY POINT START ===");
-console.error(`[DXT] Node version: ${process.version}`);
-console.error(`[DXT] Platform: ${process.platform}`);
-console.error(`[DXT] Working directory: ${process.cwd()}`);
-console.error(`[DXT] __dirname: ${__dirname}`);
-console.error(`[DXT] Args: ${JSON.stringify(process.argv)}`);
-// Add error handlers immediately
-process.on('uncaughtException', (error) => {
-    console.error(`[DXT] UNCAUGHT EXCEPTION: ${error.message}`);
-    console.error(`[DXT] Stack: ${error.stack}`);
-});
-process.on('unhandledRejection', (reason) => {
-    console.error(`[DXT] UNHANDLED REJECTION: ${String(reason)}`);
-});
-process.on('exit', (code) => {
-    console.error(`[DXT] PROCESS EXITING with code: ${code}`);
-});
-console.error("[DXT] About to import modules...");
 // Simplified entry point for DXT that avoids configuration loading issues
 import { FilteredStdioServerTransport } from './custom-stdio.js';
-console.error("[DXT] FilteredStdioServerTransport imported");
 import { server } from './server.js';
-console.error("[DXT] Server imported");
 async function runDXTServer() {
     try {
-        console.error("[DXT] === runDXTServer() START ===");
-        console.error("=== DXT DEBUG START ===");
-        console.error(`Node version: ${process.version}`);
-        console.error(`Platform: ${process.platform}`);
-        console.error(`Working directory: ${process.cwd()}`);
-        console.error(`__dirname: ${__dirname}`);
-        console.error(`Args: ${JSON.stringify(process.argv)}`);
-        console.error("=== DXT DEBUG END ===");
-        console.error("[DXT] About to create transport...");
+        console.error("Starting Desktop Commander MCP for DXT...");
         // Create transport
         const transport = new FilteredStdioServerTransport();
-        console.error("[DXT] Transport created successfully");
-        // Send structured debug info
-        transport.sendLog("info", "DXT Server Starting", {
-            nodeVersion: process.version,
-            platform: process.platform,
-            cwd: process.cwd(),
-            dirname: __dirname,
-            argv: process.argv
+        // Handle process errors gracefully
+        process.on('uncaughtException', (error) => {
+            console.error(`[DXT] Uncaught exception: ${error.message}`);
+            // Don't exit immediately - let the server handle it
+        });
+        process.on('unhandledRejection', (reason) => {
+            console.error(`[DXT] Unhandled rejection: ${reason}`);
+            // Don't exit immediately - let the server handle it
         });
-        console.error("[DXT] Debug info sent via transport");
         // Connect server
-        console.error("[DXT] About to connect server...");
         console.error("Connecting MCP server...");
         await server.connect(transport);
-        console.error("[DXT] Server connected successfully!");
         console.error("MCP server connected successfully");
-        transport.sendLog("info", "MCP server connected successfully in DXT mode");
-        console.error("[DXT] === runDXTServer() END ===");
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         const errorStack = error instanceof Error ? error.stack : undefined;
-        console.error(`[DXT] FATAL ERROR in runDXTServer: ${errorMessage}`);
+        console.error(`[DXT] FATAL ERROR: ${errorMessage}`);
         if (errorStack) {
             console.error(`[DXT] Stack: ${errorStack}`);
         }
         process.exit(1);
     }
 }
-console.error("[DXT] About to call runDXTServer...");
 // Run the server
 runDXTServer().catch((error) => {
     const errorMessage = error instanceof Error ? error.message : String(error);
-    console.error(`[DXT] Failed to start in catch block: ${errorMessage}`);
     console.error(`[DXT] Failed to start: ${errorMessage}`);
     process.exit(1);
 });
-console.error("[DXT] === ENTRY POINT END ===");

package/dist/server.js

@@ -365,6 +365,9 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         • start_process("wc -l /path/file.csv") → Line counting
                         • start_process("head -10 /path/file.csv") → File preview
                         
+                        BINARY FILE SUPPORT:
+                        For PDF, Excel, Word, archives, databases, and other binary formats, use process tools with appropriate libraries or command-line utilities.
+                        
                         INTERACTIVE PROCESSES FOR DATA ANALYSIS:
                         1. start_process("python3 -i") - Start Python REPL for data work
                         2. start_process("node -i") - Start Node.js REPL for JSON/JS
@@ -438,6 +441,9 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         4. Analyze: interact_with_process(pid, "print(df.describe())")
                         5. Continue: interact_with_process(pid, "df.groupby('column').size()")
                         
+                        BINARY FILE PROCESSING WORKFLOWS:
+                        Use appropriate Python libraries (PyPDF2, pandas, docx2txt, etc.) or command-line tools for binary file analysis.
+                        
                         SMART DETECTION:
                         - Automatically waits for REPL prompt (>>>, >, etc.)
                         - Detects errors and completion states

package/dist/tools/filesystem.js

@@ -4,6 +4,7 @@ import os from 'os';
 import fetch from 'cross-fetch';
 import { createReadStream } from 'fs';
 import { createInterface } from 'readline';
+import { isBinaryFile } from 'isbinaryfile';
 import { capture } from '../utils/capture.js';
 import { withTimeout } from '../utils/withTimeout.js';
 import { configManager } from '../config-manager.js';
@@ -78,6 +79,20 @@ async function getDefaultReadLength() {
     const config = await configManager.getConfig();
     return config.fileReadLineLimit ?? 1000; // Default to 1000 lines if not set
 }
+/**
+ * Generate instructions for handling binary files
+ * @param filePath Path to the binary file
+ * @param mimeType MIME type of the file
+ * @returns Instruction message for the LLM
+ */
+function getBinaryFileInstructions(filePath, mimeType) {
+    const fileName = path.basename(filePath);
+    return `Cannot read binary file as text: ${fileName} (${mimeType})
+
+Use start_process + interact_with_process to analyze binary files with appropriate tools (Node.js or Python libraries, command-line utilities, etc.).
+
+The read_file tool only handles text files and images.`;
+}
 // Initialize allowed directories from configuration
 async function getAllowedDirs() {
     try {
@@ -329,6 +344,16 @@ function generateEnhancedStatusMessage(readLines, offset, totalLines, isNegative
 async function readFileWithSmartPositioning(filePath, offset, length, mimeType, includeStatusMessage = true) {
     const stats = await fs.stat(filePath);
     const fileSize = stats.size;
+    // Check if the file is binary (but allow images to pass through)
+    const { isImage } = await getMimeTypeInfo(filePath);
+    if (!isImage) {
+        const isBinary = await isBinaryFile(filePath);
+        if (isBinary) {
+            // Return instructions instead of trying to read binary content
+            const instructions = getBinaryFileInstructions(filePath, mimeType);
+            throw new Error(instructions);
+        }
+    }
     // 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
@@ -574,10 +599,18 @@ export async function readFileFromDisk(filePath, offset = 0, length) {
                 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
-                const buffer = await fs.readFile(validPath);
-                const content = `Binary file content (base64 encoded):\n${buffer.toString('base64')}`;
-                return { content, mimeType: 'text/plain', isImage: false };
+                // If it's our binary file instruction error, return it as content
+                if (error instanceof Error && error.message.includes('Cannot read binary file as text:')) {
+                    return { content: error.message, mimeType: 'text/plain', isImage: false };
+                }
+                // If UTF-8 reading fails for other reasons, also check if it's binary
+                const isBinary = await isBinaryFile(validPath);
+                if (isBinary) {
+                    const instructions = getBinaryFileInstructions(validPath, mimeType);
+                    return { content: instructions, mimeType: 'text/plain', isImage: false };
+                }
+                // Only if it's truly not binary, then we have a real UTF-8 reading error
+                throw error;
             }
         }
     };

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.2.6";
+export declare const VERSION = "0.2.7";

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.2.6';
+export const VERSION = '0.2.7';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wonderwhy-er/desktop-commander",
-  "version": "0.2.6",
+  "version": "0.2.7",
   "description": "MCP server for terminal operations and file editing",
   "license": "MIT",
   "author": "Eduards Ruzga",
@@ -71,6 +71,7 @@
     "cross-fetch": "^4.1.0",
     "fastest-levenshtein": "^1.0.16",
     "glob": "^10.3.10",
+    "isbinaryfile": "^5.0.4",
     "zod": "^3.24.1",
     "zod-to-json-schema": "^3.23.5"
   },

package/dist/REPLSessionManager.d.ts

@@ -1,109 +0,0 @@
-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

@@ -1,364 +0,0 @@
-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

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