@wonderwhy-er/desktop-commander 0.2.5 → 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/utils/usageTracker.js

@@ -149,18 +149,21 @@ class UsageTracker {
      * Check if user should be prompted for feedback based on usage patterns
      */
     async shouldPromptForFeedback() {
+        return false;
+        /* TODO Turn off feedback requests until further issue investigation
         const stats = await this.getStats();
+    
         // Don't prompt if feedback already given (check top-level config)
         const feedbackGiven = await configManager.getValue('feedbackGiven');
-        if (feedbackGiven === true)
-            return false;
+        if (feedbackGiven === true) return false;
+    
         // Check if enough time has passed since last prompt (2 hours minimum)
         const now = Date.now();
         const hoursSinceLastPrompt = (now - stats.lastFeedbackPrompt) / (1000 * 60 * 60);
-        if (stats.lastFeedbackPrompt > 0 && hoursSinceLastPrompt < 2)
-            return false;
+        if (stats.lastFeedbackPrompt > 0 && hoursSinceLastPrompt < 2) return false;
+    
         // MAIN TRIGGER: 25+ total tool calls (earlier trigger for faster feedback)
-        return stats.totalToolCalls >= 25;
+        return stats.totalToolCalls >= 25;*/
     }
     /**
      * Get a random feedback prompt message with strong CTAs and clear actions

package/dist/version.d.ts

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

package/dist/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wonderwhy-er/desktop-commander",
-  "version": "0.2.5",
+  "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 {};