@wonderwhy-er/desktop-commander 0.2.6 → 0.2.8

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/setup-claude-server.js

@@ -1,4 +1,6 @@
 import { homedir, platform } from 'os';
+import fs from 'fs/promises';
+import path from 'path';
 import { join } from 'path';
 import { readFileSync, writeFileSync, existsSync, appendFileSync, mkdirSync } from 'fs';
 import { fileURLToPath } from 'url';
@@ -29,6 +31,96 @@ try {
 let setupSteps = []; // Track setup progress
 let setupStartTime = Date.now();
 
+/**
+   * Initialize configuration - load from disk or create default
+   */
+async function initConfigFile() {
+    const USER_HOME = homedir();
+    const CONFIG_DIR = path.join(USER_HOME, '.claude-server-commander');
+
+    // Paths relative to the config directory
+    const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+    try {
+        // Ensure config directory exists
+        const configDir = path.dirname(CONFIG_FILE);
+        if (!existsSync(configDir)) {
+            await mkdir(configDir, { recursive: true });
+        }
+
+        // Check if config file exists
+        try {
+            await fs.access(CONFIG_FILE);
+            // Load existing config
+            const configData = await fs.readFile(CONFIG_FILE, 'utf8');
+        } catch (error) {
+            const defaultConfig = {
+                blockedCommands: [
+
+                    // Disk and partition management
+                    "mkfs",      // Create a filesystem on a device
+                    "format",    // Format a storage device (cross-platform)
+                    "mount",     // Mount a filesystem
+                    "umount",    // Unmount a filesystem
+                    "fdisk",     // Manipulate disk partition tables
+                    "dd",        // Convert and copy files, can write directly to disks
+                    "parted",    // Disk partition manipulator
+                    "diskpart",  // Windows disk partitioning utility
+                    
+                    // System administration and user management
+                    "sudo",      // Execute command as superuser
+                    "su",        // Substitute user identity
+                    "passwd",    // Change user password
+                    "adduser",   // Add a user to the system
+                    "useradd",   // Create a new user
+                    "usermod",   // Modify user account
+                    "groupadd",  // Create a new group
+                    "chsh",      // Change login shell
+                    "visudo",    // Edit the sudoers file
+                    
+                    // System control
+                    "shutdown",  // Shutdown the system
+                    "reboot",    // Restart the system
+                    "halt",      // Stop the system
+                    "poweroff",  // Power off the system
+                    "init",      // Change system runlevel
+                    
+                    // Network and security
+                    "iptables",  // Linux firewall administration
+                    "firewall",  // Generic firewall command
+                    "netsh",     // Windows network configuration
+                    
+                    // Windows system commands
+                    "sfc",       // System File Checker
+                    "bcdedit",   // Boot Configuration Data editor
+                    "reg",       // Windows registry editor
+                    "net",       // Network/user/service management
+                    "sc",        // Service Control manager
+                    "runas",     // Execute command as another user
+                    "cipher",    // Encrypt/decrypt files or wipe data
+                    "takeown"    // Take ownership of files
+                ],
+                clientId: uniqueUserId, // Use the generated UUID as client ID
+                defaultShell: platform() === 'win32' ? 'powershell.exe' : '/bin/sh',
+                allowedDirectories: [],
+                telemetryEnabled: true, // Default to opt-out approach (telemetry on by default)
+                fileWriteLineLimit: 50,  // Default line limit for file write operations (changed from 100)
+                fileReadLineLimit: 1000  // Default line limit for file read operations (changed from character-based)
+            };
+            logToFile('User id ' + uniqueUserId);
+            try {
+                await fs.writeFile(CONFIG_FILE, JSON.stringify(defaultConfig, null, 2), 'utf8');
+            } catch (error) {
+                console.error('Failed to save config:', error);
+                throw error;
+            }
+        }
+
+    } catch (error) {
+        console.error('Failed to initialize config:', error);
+    }
+}
+
+
 
 // Function to get npm version
 async function getNpmVersion() {
@@ -532,6 +624,7 @@ export default async function setup() {
     }
 
     try {
+        await initConfigFile();
         // Check if config directory exists and create it if necessary
         const configDirStep = addSetupStep('check_config_directory');
         const configDir = dirname(claudeConfigPath);

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.8";

package/dist/version.js

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

package/package.json

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