@wonderwhy-er/desktop-commander 0.1.26 → 0.1.28

package/README.md

@@ -1,4 +1,5 @@
 # Desktop Commander MCP
+### Search, update, manage files and run terminal commands with AI
 
 [![npm downloads](https://img.shields.io/npm/dw/@wonderwhy-er/desktop-commander)](https://www.npmjs.com/package/@wonderwhy-er/desktop-commander)
 [![smithery badge](https://smithery.ai/badge/@wonderwhy-er/desktop-commander)](https://smithery.ai/server/@wonderwhy-er/desktop-commander)
@@ -8,8 +9,8 @@
 
 Short version. Two key things. Terminal commands and diff based file editing.
 
-![Desktop Commander MCP](https://raw.githubusercontent.com/wonderwhy-er/ClaudeComputerCommander/main/logo.png)
 
+![Desktop Commander MCP](https://raw.githubusercontent.com/wonderwhy-er/ClaudeComputerCommander/main/header.png)
 <a href="https://glama.ai/mcp/servers/zempur9oh4">
   <img width="380" height="200" src="https://glama.ai/mcp/servers/zempur9oh4/badge" alt="Claude Desktop Commander MCP server" />
 </a>
@@ -53,7 +54,12 @@ First, ensure you've downloaded and installed the [Claude Desktop app](https://c
 ### Option 1: Install through npx
 Just run this in terminal
 ```
-npx @wonderwhy-er/desktop-commander setup
+npx @wonderwhy-er/desktop-commander@latest setup
+```
+
+For debugging mode (allows Node.js inspector connection):
+```
+npx @wonderwhy-er/desktop-commander@latest setup --debug
 ```
 Restart Claude if running
 
@@ -156,6 +162,40 @@ For commands that may take a while:
 3. Use `read_output` with PID to get new output
 4. Use `force_terminate` to stop if needed
 
+## Debugging
+
+If you need to debug the server, you can install it in debug mode:
+
+```bash
+# Using npx
+npx @wonderwhy-er/desktop-commander@latest setup --debug
+
+# Or if installed locally
+npm run setup:debug
+```
+
+This will:
+1. Configure Claude to use a separate "desktop-commander" server
+2. Enable Node.js inspector protocol with `--inspect-brk=9229` flag
+3. Pause execution at the start until a debugger connects
+4. Enable additional debugging environment variables
+
+To connect a debugger:
+- In Chrome, visit `chrome://inspect` and look for the Node.js instance
+- In VS Code, use the "Attach to Node Process" debug configuration
+- Other IDEs/tools may have similar "attach" options for Node.js debugging
+
+Important debugging notes:
+- The server will pause on startup until a debugger connects (due to the `--inspect-brk` flag)
+- If you don't see activity during debugging, ensure you're connected to the correct Node.js process
+- Multiple Node processes may be running; connect to the one on port 9229
+- The debug server is identified as "desktop-commander-debug" in Claude's MCP server list
+
+Troubleshooting:
+- If Claude times out while trying to use the debug server, your debugger might not be properly connected
+- When properly connected, the process will continue execution after hitting the first breakpoint
+- You can add additional breakpoints in your IDE once connected
+
 ## Model Context Protocol Integration
 
 This project extends the MCP Filesystem Server to enable:

package/dist/command-manager.d.ts

@@ -3,6 +3,8 @@ declare class CommandManager {
     loadBlockedCommands(): Promise<void>;
     saveBlockedCommands(): Promise<void>;
     getBaseCommand(command: string): string;
+    extractCommands(commandString: string): string[];
+    extractBaseCommand(commandStr: string): string | null;
     validateCommand(command: string): boolean;
     blockCommand(command: string): Promise<boolean>;
     unblockCommand(command: string): Promise<boolean>;

package/dist/command-manager.js

@@ -28,6 +28,132 @@ class CommandManager {
     getBaseCommand(command) {
         return command.split(' ')[0].toLowerCase().trim();
     }
+    extractCommands(commandString) {
+        try {
+            // Trim any leading/trailing whitespace
+            commandString = commandString.trim();
+            // Define command separators - these are the operators that can chain commands
+            const separators = [';', '&&', '||', '|', '&'];
+            // This will store our extracted commands
+            const commands = [];
+            // Split by common separators while preserving quotes
+            let inQuote = false;
+            let quoteChar = '';
+            let currentCmd = '';
+            let escaped = false;
+            for (let i = 0; i < commandString.length; i++) {
+                const char = commandString[i];
+                // Handle escape characters
+                if (char === '\\' && !escaped) {
+                    escaped = true;
+                    currentCmd += char;
+                    continue;
+                }
+                // If this character is escaped, just add it
+                if (escaped) {
+                    escaped = false;
+                    currentCmd += char;
+                    continue;
+                }
+                // Handle quotes (both single and double)
+                if ((char === '"' || char === "'") && !inQuote) {
+                    inQuote = true;
+                    quoteChar = char;
+                    currentCmd += char;
+                    continue;
+                }
+                else if (char === quoteChar && inQuote) {
+                    inQuote = false;
+                    quoteChar = '';
+                    currentCmd += char;
+                    continue;
+                }
+                // If we're inside quotes, just add the character
+                if (inQuote) {
+                    currentCmd += char;
+                    continue;
+                }
+                // Handle subshells - if we see an opening parenthesis, we need to find its matching closing parenthesis
+                if (char === '(') {
+                    // Find the matching closing parenthesis
+                    let openParens = 1;
+                    let j = i + 1;
+                    while (j < commandString.length && openParens > 0) {
+                        if (commandString[j] === '(')
+                            openParens++;
+                        if (commandString[j] === ')')
+                            openParens--;
+                        j++;
+                    }
+                    // Skip to after the closing parenthesis
+                    if (j <= commandString.length) {
+                        const subshellContent = commandString.substring(i + 1, j - 1);
+                        // Recursively extract commands from the subshell
+                        const subCommands = this.extractCommands(subshellContent);
+                        commands.push(...subCommands);
+                        // Move position past the subshell
+                        i = j - 1;
+                        continue;
+                    }
+                }
+                // Check for separators
+                let isSeparator = false;
+                for (const separator of separators) {
+                    if (commandString.startsWith(separator, i)) {
+                        // We found a separator - extract the command before it
+                        if (currentCmd.trim()) {
+                            const baseCommand = this.extractBaseCommand(currentCmd.trim());
+                            if (baseCommand)
+                                commands.push(baseCommand);
+                        }
+                        // Move past the separator
+                        i += separator.length - 1;
+                        currentCmd = '';
+                        isSeparator = true;
+                        break;
+                    }
+                }
+                if (!isSeparator) {
+                    currentCmd += char;
+                }
+            }
+            // Don't forget to add the last command
+            if (currentCmd.trim()) {
+                const baseCommand = this.extractBaseCommand(currentCmd.trim());
+                if (baseCommand)
+                    commands.push(baseCommand);
+            }
+            // Remove duplicates and return
+            return [...new Set(commands)];
+        }
+        catch (error) {
+            // If anything goes wrong, log the error but return the basic command to not break execution
+            console.error('Error extracting commands:', error);
+            return [this.getBaseCommand(commandString)];
+        }
+    }
+    // This extracts the actual command name from a command string
+    extractBaseCommand(commandStr) {
+        try {
+            // Remove environment variables (patterns like KEY=value)
+            const withoutEnvVars = commandStr.replace(/\w+=\S+\s*/g, '').trim();
+            // If nothing remains after removing env vars, return null
+            if (!withoutEnvVars)
+                return null;
+            // Get the first token (the command)
+            const tokens = withoutEnvVars.split(/\s+/);
+            const firstToken = tokens[0];
+            // Check if it starts with special characters like (, $ that might indicate it's not a regular command
+            if (['(', '$'].includes(firstToken[0])) {
+                return null;
+            }
+            return firstToken.toLowerCase();
+        }
+        catch (error) {
+            console.error('Error extracting base command:', error);
+            return null;
+        }
+    }
     validateCommand(command) {
         const baseCommand = this.getBaseCommand(command);
         return !this.blockedCommands.has(baseCommand);

package/dist/index.js

@@ -80,6 +80,7 @@ async function runServer() {
             process.stderr.write(`[desktop-commander] Unhandled rejection: ${errorMessage}\n`);
             process.exit(1);
         });
+        capture('run_server_start');
         // Load blocked commands from config file
         await commandManager.loadBlockedCommands();
         await server.connect(transport);

package/dist/server.js

@@ -179,20 +179,22 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
     try {
         const { name, arguments: args } = request.params;
+        capture('server_call_tool');
         switch (name) {
             // Terminal tools
             case "execute_command": {
+                capture('server_execute_command');
                 const parsed = ExecuteCommandArgsSchema.parse(args);
                 return executeCommand(parsed);
             }
             case "read_output": {
-                const parsed = ReadOutputArgsSchema.parse(args);
                 capture('server_read_output');
+                const parsed = ReadOutputArgsSchema.parse(args);
                 return readOutput(parsed);
             }
             case "force_terminate": {
-                const parsed = ForceTerminateArgsSchema.parse(args);
                 capture('server_force_terminate');
+                const parsed = ForceTerminateArgsSchema.parse(args);
                 return forceTerminate(parsed);
             }
             case "list_sessions":
@@ -202,11 +204,12 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 capture('server_list_processes');
                 return listProcesses();
             case "kill_process": {
-                const parsed = KillProcessArgsSchema.parse(args);
                 capture('server_kill_process');
+                const parsed = KillProcessArgsSchema.parse(args);
                 return killProcess(parsed);
             }
             case "block_command": {
+                capture('server_block_command');
                 const parsed = BlockCommandArgsSchema.parse(args);
                 const blockResult = await commandManager.blockCommand(parsed.command);
                 return {
@@ -214,6 +217,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 };
             }
             case "unblock_command": {
+                capture('server_unblock_command');
                 const parsed = UnblockCommandArgsSchema.parse(args);
                 const unblockResult = await commandManager.unblockCommand(parsed.command);
                 return {
@@ -221,6 +225,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 };
             }
             case "list_blocked_commands": {
+                capture('server_list_blocked_commands');
                 const blockedCommands = await commandManager.listBlockedCommands();
                 return {
                     content: [{ type: "text", text: blockedCommands.join('\n') }],
@@ -228,85 +233,158 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             }
             // Filesystem tools
             case "edit_block": {
-                const parsed = EditBlockArgsSchema.parse(args);
-                const { filePath, searchReplace } = await parseEditBlock(parsed.blockContent);
-                await performSearchReplace(filePath, searchReplace);
                 capture('server_edit_block');
-                return {
-                    content: [{ type: "text", text: `Successfully applied edit to ${filePath}` }],
-                };
+                try {
+                    const parsed = EditBlockArgsSchema.parse(args);
+                    const { filePath, searchReplace } = await parseEditBlock(parsed.blockContent);
+                    await performSearchReplace(filePath, searchReplace);
+                    return {
+                        content: [{ type: "text", text: `Successfully applied edit to ${filePath}` }],
+                    };
+                }
+                catch (error) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    return {
+                        content: [{ type: "text", text: `Error: ${errorMessage}` }],
+                    };
+                }
             }
             case "read_file": {
-                const parsed = ReadFileArgsSchema.parse(args);
-                const content = await readFile(parsed.path);
                 capture('server_read_file');
-                return {
-                    content: [{ type: "text", text: content }],
-                };
+                try {
+                    const parsed = ReadFileArgsSchema.parse(args);
+                    const content = await readFile(parsed.path);
+                    return {
+                        content: [{ type: "text", text: content }],
+                    };
+                }
+                catch (error) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    return {
+                        content: [{ type: "text", text: `Error: ${errorMessage}` }],
+                    };
+                }
             }
             case "read_multiple_files": {
-                const parsed = ReadMultipleFilesArgsSchema.parse(args);
-                const results = await readMultipleFiles(parsed.paths);
                 capture('server_read_multiple_files');
-                return {
-                    content: [{ type: "text", text: results.join("\n---\n") }],
-                };
+                try {
+                    const parsed = ReadMultipleFilesArgsSchema.parse(args);
+                    const results = await readMultipleFiles(parsed.paths);
+                    return {
+                        content: [{ type: "text", text: results.join("\n---\n") }],
+                    };
+                }
+                catch (error) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    return {
+                        content: [{ type: "text", text: `Error: ${errorMessage}` }],
+                    };
+                }
             }
             case "write_file": {
-                const parsed = WriteFileArgsSchema.parse(args);
-                await writeFile(parsed.path, parsed.content);
                 capture('server_write_file');
-                return {
-                    content: [{ type: "text", text: `Successfully wrote to ${parsed.path}` }],
-                };
+                try {
+                    const parsed = WriteFileArgsSchema.parse(args);
+                    await writeFile(parsed.path, parsed.content);
+                    return {
+                        content: [{ type: "text", text: `Successfully wrote to ${parsed.path}` }],
+                    };
+                }
+                catch (error) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    return {
+                        content: [{ type: "text", text: `Error: ${errorMessage}` }],
+                    };
+                }
             }
             case "create_directory": {
-                const parsed = CreateDirectoryArgsSchema.parse(args);
-                await createDirectory(parsed.path);
                 capture('server_create_directory');
-                return {
-                    content: [{ type: "text", text: `Successfully created directory ${parsed.path}` }],
-                };
+                try {
+                    const parsed = CreateDirectoryArgsSchema.parse(args);
+                    await createDirectory(parsed.path);
+                    return {
+                        content: [{ type: "text", text: `Successfully created directory ${parsed.path}` }],
+                    };
+                }
+                catch (error) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    return {
+                        content: [{ type: "text", text: `Error: ${errorMessage}` }],
+                    };
+                }
             }
             case "list_directory": {
-                const parsed = ListDirectoryArgsSchema.parse(args);
-                const entries = await listDirectory(parsed.path);
                 capture('server_list_directory');
-                return {
-                    content: [{ type: "text", text: entries.join('\n') }],
-                };
+                try {
+                    const parsed = ListDirectoryArgsSchema.parse(args);
+                    const entries = await listDirectory(parsed.path);
+                    return {
+                        content: [{ type: "text", text: entries.join('\n') }],
+                    };
+                }
+                catch (error) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    return {
+                        content: [{ type: "text", text: `Error: ${errorMessage}` }],
+                    };
+                }
             }
             case "move_file": {
-                const parsed = MoveFileArgsSchema.parse(args);
-                await moveFile(parsed.source, parsed.destination);
                 capture('server_move_file');
-                return {
-                    content: [{ type: "text", text: `Successfully moved ${parsed.source} to ${parsed.destination}` }],
-                };
+                try {
+                    const parsed = MoveFileArgsSchema.parse(args);
+                    await moveFile(parsed.source, parsed.destination);
+                    return {
+                        content: [{ type: "text", text: `Successfully moved ${parsed.source} to ${parsed.destination}` }],
+                    };
+                }
+                catch (error) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    return {
+                        content: [{ type: "text", text: `Error: ${errorMessage}` }],
+                    };
+                }
             }
             case "search_files": {
-                const parsed = SearchFilesArgsSchema.parse(args);
-                const results = await searchFiles(parsed.path, parsed.pattern);
                 capture('server_search_files');
-                return {
-                    content: [{ type: "text", text: results.length > 0 ? results.join('\n') : "No matches found" }],
-                };
+                try {
+                    const parsed = SearchFilesArgsSchema.parse(args);
+                    const results = await searchFiles(parsed.path, parsed.pattern);
+                    return {
+                        content: [{ type: "text", text: results.length > 0 ? results.join('\n') : "No matches found" }],
+                    };
+                }
+                catch (error) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    return {
+                        content: [{ type: "text", text: `Error: ${errorMessage}` }],
+                    };
+                }
             }
             case "search_code": {
-                const parsed = SearchCodeArgsSchema.parse(args);
-                const results = await searchTextInFiles({
-                    rootPath: parsed.path,
-                    pattern: parsed.pattern,
-                    filePattern: parsed.filePattern,
-                    ignoreCase: parsed.ignoreCase,
-                    maxResults: parsed.maxResults,
-                    includeHidden: parsed.includeHidden,
-                    contextLines: parsed.contextLines,
-                });
                 capture('server_search_code');
-                if (results.length === 0) {
+                let results = [];
+                try {
+                    const parsed = SearchCodeArgsSchema.parse(args);
+                    results = await searchTextInFiles({
+                        rootPath: parsed.path,
+                        pattern: parsed.pattern,
+                        filePattern: parsed.filePattern,
+                        ignoreCase: parsed.ignoreCase,
+                        maxResults: parsed.maxResults,
+                        includeHidden: parsed.includeHidden,
+                        contextLines: parsed.contextLines,
+                    });
+                    if (results.length === 0) {
+                        return {
+                            content: [{ type: "text", text: "No matches found" }],
+                        };
+                    }
+                }
+                catch (error) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
                     return {
-                        content: [{ type: "text", text: "No matches found" }],
+                        content: [{ type: "text", text: `Error: ${errorMessage}` }],
                     };
                 }
                 // Format the results in a VS Code-like format
@@ -324,21 +402,29 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 };
             }
             case "get_file_info": {
-                const parsed = GetFileInfoArgsSchema.parse(args);
-                const info = await getFileInfo(parsed.path);
                 capture('server_get_file_info');
-                return {
-                    content: [{
-                            type: "text",
-                            text: Object.entries(info)
-                                .map(([key, value]) => `${key}: ${value}`)
-                                .join('\n')
-                        }],
-                };
+                try {
+                    const parsed = GetFileInfoArgsSchema.parse(args);
+                    const info = await getFileInfo(parsed.path);
+                    return {
+                        content: [{
+                                type: "text",
+                                text: Object.entries(info)
+                                    .map(([key, value]) => `${key}: ${value}`)
+                                    .join('\n')
+                            }],
+                    };
+                }
+                catch (error) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    return {
+                        content: [{ type: "text", text: `Error: ${errorMessage}` }],
+                    };
+                }
             }
             case "list_allowed_directories": {
-                const directories = listAllowedDirectories();
                 capture('server_list_allowed_directories');
+                const directories = listAllowedDirectories();
                 return {
                     content: [{
                             type: "text",
@@ -347,6 +433,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 };
             }
             default:
+                capture('server_unknow_tool', {
+                    name
+                });
                 throw new Error(`Unknown tool: ${name}`);
         }
     }

package/dist/setup-claude-server.js

@@ -4,20 +4,30 @@ import { readFileSync, writeFileSync, existsSync, appendFileSync } from 'fs';
 import { fileURLToPath } from 'url';
 import { dirname } from 'path';
 import { exec } from "node:child_process";
-import { PostHog } from 'posthog-node';
-import machineId from 'node-machine-id';
 import { version as nodeVersion } from 'process';
 
-const client = new PostHog(
-    'phc_TFQqTkCwtFGxlwkXDY3gSs7uvJJcJu8GurfXd6mV063',
-    { 
-        host: 'https://eu.i.posthog.com',
-        flushAt: 1, // send all every time
-        flushInterval: 0 //send always
-    }
-)
-// Get a unique user ID
-const uniqueUserId = machineId.machineIdSync();
+// Optional analytics - will gracefully degrade if posthog-node isn't available
+let client = null;
+let uniqueUserId = 'unknown';
+
+try {
+    const { PostHog } = await import('posthog-node');
+    const machineIdModule = await import('node-machine-id');
+    
+    client = new PostHog(
+        'phc_TFQqTkCwtFGxlwkXDY3gSs7uvJJcJu8GurfXd6mV063',
+        { 
+            host: 'https://eu.i.posthog.com',
+            flushAt: 1, // send all every time
+            flushInterval: 0 //send always
+        }
+    );
+    
+    // Get a unique user ID
+    uniqueUserId = machineIdModule.machineIdSync();
+} catch (error) {
+    //console.error('Analytics module not available - continuing without tracking');
+}
 
 // Function to get npm version
 async function getNpmVersion() {
@@ -118,14 +128,24 @@ async function getTrackingProperties(additionalProps = {}) {
   };
 }
 
+// Helper function for tracking that handles missing PostHog gracefully
+async function trackEvent(eventName, additionalProps = {}) {
+  if (!client) return; // Skip tracking if PostHog client isn't available
+  
+  try {
+    client.capture({
+      distinctId: uniqueUserId,
+      event: eventName,
+      properties: await getTrackingProperties(additionalProps)
+    });
+  } catch (error) {
+    // Silently fail if tracking fails - we don't want to break the setup process
+    //console.log(`Note: Event tracking unavailable for ${eventName}`);
+  }
+}
+
 // Initial tracking
-(async () => {
-  client.capture({
-    distinctId: uniqueUserId,
-    event: 'npx_setup_start',
-    properties: await getTrackingProperties()
-  });
-})();
+trackEvent('npx_setup_start');
 
 // Fix for Windows ESM path resolution
 const __filename = fileURLToPath(import.meta.url);
@@ -219,23 +239,20 @@ async function restartClaude() {
             }
         } catch {}
 		await new Promise((resolve) => setTimeout(resolve, 3000))
-
-		if (platform === "win32") {
-            // it will never start claude
-			// await execAsync(`start "" "Claude.exe"`)
-		} else if (platform === "darwin") {
-			await execAsync(`open -a "Claude"`)
-		} else if (platform === "linux") {
-			await execAsync(`claude`)
-		}
+        try {
+            if (platform === "win32") {
+                // it will never start claude
+                // await execAsync(`start "" "Claude.exe"`)
+            } else if (platform === "darwin") {
+                await execAsync(`open -a "Claude"`)
+            } else if (platform === "linux") {
+                await execAsync(`claude`)
+            }
+        } catch{}
 
 		logToFile(`Claude has been restarted.`)
 	} catch (error) {
-        client.capture({
-            distinctId: uniqueUserId,
-            event: 'npx_setup_restart_claude_error',
-            properties: await getTrackingProperties({ error: error.message })
-        });
+        await trackEvent('npx_setup_restart_claude_error', { error: error.message });
 		logToFile(`Failed to restart Claude: ${error}`, true)
 	}
 }
@@ -246,11 +263,7 @@ if (!existsSync(claudeConfigPath)) {
     logToFile('Creating default config file...');
     
     // Track new installation
-    client.capture({
-        distinctId: uniqueUserId,
-        event: 'npx_setup_create_default_config',
-        properties: await getTrackingProperties()
-    });
+    await trackEvent('npx_setup_create_default_config');
     
     // Create the directory if it doesn't exist
     const configDir = dirname(claudeConfigPath);
@@ -275,8 +288,17 @@ if (!existsSync(claudeConfigPath)) {
     logToFile('Default config file created. Please update it with your Claude API credentials.');
 }
 
+// Function to check for debug mode argument
+function isDebugMode() {
+    return process.argv.includes('--debug');
+}
+
 // Main function to export for ESM compatibility
 export default async function setup() {
+    const debugMode = isDebugMode();
+    if (debugMode) {
+        logToFile('Debug mode enabled. Will configure with Node.js inspector options.');
+    }
     try {
         // Read existing config
         const configData = readFileSync(claudeConfigPath, 'utf8');
@@ -288,22 +310,67 @@ export default async function setup() {
 
         // Fix Windows path handling for npx execution
         let serverConfig;
-        if (isNpx) {
-            serverConfig = {
-                "command": isWindows ? "npx.cmd" : "npx",
-                "args": [
-                    "@wonderwhy-er/desktop-commander"
-                ]
-            };
+        
+        if (debugMode) {
+            // Use Node.js with inspector flag for debugging
+            if (isNpx) {
+                // Debug with npx
+                logToFile('Setting up debug configuration with npx. The process will pause on start until a debugger connects.');
+                // Add environment variables to help with debugging
+                const debugEnv = {
+                    "NODE_OPTIONS": "--trace-warnings --trace-exit",
+                    "DEBUG": "*"
+                };
+                
+                serverConfig = {
+                    "command": isWindows ? "node.exe" : "node",
+                    "args": [
+                        "--inspect-brk=9229",
+                        isWindows ? 
+                            join(process.env.APPDATA || '', "npm", "npx.cmd").replace(/\\/g, '\\\\') : 
+                            "$(which npx)",
+                        "@wonderwhy-er/desktop-commander"
+                    ],
+                    "env": debugEnv
+                };
+            } else {
+                // Debug with local installation path
+                const indexPath = join(__dirname, 'dist', 'index.js');
+                logToFile('Setting up debug configuration with local path. The process will pause on start until a debugger connects.');
+                // Add environment variables to help with debugging
+                const debugEnv = {
+                    "NODE_OPTIONS": "--trace-warnings --trace-exit",
+                    "DEBUG": "*"
+                };
+                
+                serverConfig = {
+                    "command": isWindows ? "node.exe" : "node",
+                    "args": [
+                        "--inspect-brk=9229",
+                        indexPath.replace(/\\/g, '\\\\') // Double escape backslashes for JSON
+                    ],
+                    "env": debugEnv
+                };
+            }
         } else {
-            // For local installation, use absolute path to handle Windows properly
-            const indexPath = join(__dirname, 'dist', 'index.js');
-            serverConfig = {
-                "command": "node",
-                "args": [
-                    indexPath.replace(/\\/g, '\\\\') // Double escape backslashes for JSON
-                ]
-            };
+            // Standard configuration without debug
+            if (isNpx) {
+                serverConfig = {
+                    "command": isWindows ? "npx.cmd" : "npx",
+                    "args": [
+                        "@wonderwhy-er/desktop-commander"
+                    ]
+                };
+            } else {
+                // For local installation, use absolute path to handle Windows properly
+                const indexPath = join(__dirname, 'dist', 'index.js');
+                serverConfig = {
+                    "command": "node",
+                    "args": [
+                        indexPath.replace(/\\/g, '\\\\') // Double escape backslashes for JSON
+                    ]
+                };
+            }
         }
 
         // Initialize mcpServers if it doesn't exist
@@ -322,31 +389,40 @@ export default async function setup() {
 
         // Write the updated config back
         writeFileSync(claudeConfigPath, JSON.stringify(config, null, 2), 'utf8');
-        client.capture({
-            distinctId: uniqueUserId,
-            event: 'npx_setup_update_config',
-            properties: await getTrackingProperties()
-        });
+        await trackEvent('npx_setup_update_config');
         logToFile('Successfully added MCP server to Claude configuration!');
         logToFile(`Configuration location: ${claudeConfigPath}`);
-        logToFile('\nTo use the server:\n1. Restart Claude if it\'s currently running\n2. The server will be available as "desktop-commander" in Claude\'s MCP server list');
+        
+        if (debugMode) {
+            logToFile('\nTo use the debug server:\n1. Restart Claude if it\'s currently running\n2. The server will be available as "desktop-commander-debug" in Claude\'s MCP server list\n3. Connect your debugger to port 9229');
+        } else {
+            logToFile('\nTo use the server:\n1. Restart Claude if it\'s currently running\n2. The server will be available as "desktop-commander" in Claude\'s MCP server list');
+        }
 
         await restartClaude();
         
-        client.capture({
-            distinctId: uniqueUserId,
-            event: 'npx_setup_complete',
-            properties: await getTrackingProperties()
-        });
-        await client.shutdown() 
+        await trackEvent('npx_setup_complete');
+        
+        // Safe shutdown
+        if (client) {
+            try {
+                await client.shutdown();
+            } catch (error) {
+                // Ignore shutdown errors
+            }
+        }
     } catch (error) {
-        client.capture({
-            distinctId: uniqueUserId,
-            event: 'npx_setup_final_error',
-            properties: await getTrackingProperties({ error: error.message })
-        });
+        await trackEvent('npx_setup_final_error', { error: error.message });
         logToFile(`Error updating Claude configuration: ${error}`, true);
-        await client.shutdown() 
+        
+        // Safe shutdown
+        if (client) {
+            try {
+                await client.shutdown();
+            } catch (error) {
+                // Ignore shutdown errors
+            }
+        }
         process.exit(1);
     }
 }

package/dist/tools/execute.js

@@ -8,9 +8,22 @@ export async function executeCommand(args) {
         capture('server_execute_command_failed');
         throw new Error(`Invalid arguments for execute_command: ${parsed.error}`);
     }
-    capture('server_execute_command', {
-        command: commandManager.getBaseCommand(parsed.data.command)
-    });
+    try {
+        // Extract all commands for analytics while ensuring execution continues even if parsing fails
+        const commands = commandManager.extractCommands(parsed.data.command);
+        capture('server_execute_command', {
+            command: commandManager.getBaseCommand(parsed.data.command), // Keep original for backward compatibility
+            commands: commands // Add the array of all identified commands
+        });
+    }
+    catch (error) {
+        // If anything goes wrong with command extraction, just continue with execution
+        capture('server_execute_command', {
+            command: commandManager.getBaseCommand(parsed.data.command)
+        });
+        // Log the error but continue execution
+        console.error('Error during command extraction:', error);
+    }
     if (!commandManager.validateCommand(parsed.data.command)) {
         throw new Error(`Command not allowed: ${parsed.data.command}`);
     }

package/dist/tools/filesystem.js

@@ -27,17 +27,21 @@ function expandHome(filepath) {
 export async function validatePath(requestedPath) {
     // Temporarily allow all paths by just returning the resolved path
     // TODO: Implement configurable path validation
+    // Expand home directory if present
     const expandedPath = expandHome(requestedPath);
+    // Convert to absolute path
     const absolute = path.isAbsolute(expandedPath)
         ? path.resolve(expandedPath)
         : path.resolve(process.cwd(), expandedPath);
-    // Try to resolve real path for symlinks, but don't enforce restrictions
+    // Check if path exists
     try {
+        const stats = await fs.stat(absolute);
+        // If path exists, resolve any symlinks
         return await fs.realpath(absolute);
     }
     catch (error) {
-        // If can't resolve (e.g., file doesn't exist yet), return absolute path
-        return absolute;
+        // Path doesn't exist, throw an error
+        throw new Error(`Path does not exist: ${absolute}`);
     }
     /* Original implementation commented out for future reference
     const expandedPath = expandHome(requestedPath);
@@ -135,6 +139,7 @@ export async function searchFiles(rootPath, pattern) {
             }
         }
     }
+    // if path not exist, it will throw an error
     const validPath = await validatePath(rootPath);
     await search(validPath);
     return results;

package/dist/utils.js

@@ -1,23 +1,49 @@
-import { PostHog } from 'posthog-node';
-import machineId from 'node-machine-id';
 import { platform } from 'os';
+// Set default tracking state
 const isTrackingEnabled = true;
-const uniqueUserId = machineId.machineIdSync();
-const posthog = isTrackingEnabled ? new PostHog('phc_TFQqTkCwtFGxlwkXDY3gSs7uvJJcJu8GurfXd6mV063', {
-    host: 'https://eu.i.posthog.com',
-    flushAt: 3, // send all every time
-    flushInterval: 5 //send always
-}) : null;
+let uniqueUserId = 'unknown';
+let posthog = null;
+// Try to load PostHog without breaking if it's not available
+try {
+    // Dynamic imports to prevent crashing if dependencies aren't available
+    import('posthog-node').then((posthogModule) => {
+        const PostHog = posthogModule.PostHog;
+        import('node-machine-id').then((machineIdModule) => {
+            // Access the default export from the module
+            uniqueUserId = machineIdModule.default.machineIdSync();
+            if (isTrackingEnabled) {
+                posthog = new PostHog('phc_TFQqTkCwtFGxlwkXDY3gSs7uvJJcJu8GurfXd6mV063', {
+                    host: 'https://eu.i.posthog.com',
+                    flushAt: 3, // send all every time
+                    flushInterval: 5 // send always
+                });
+            }
+        }).catch(() => {
+            // Silently fail - we don't want analytics issues to break functionality
+        });
+    }).catch(() => {
+        // Silently fail - we don't want analytics issues to break functionality
+    });
+}
+catch (error) {
+    //console.log('Analytics module not available - continuing without tracking');
+}
 export const capture = (event, properties) => {
     if (!posthog || !isTrackingEnabled) {
         return;
     }
-    properties = properties || {};
-    properties.timestamp = new Date().toISOString();
-    properties.platform = platform();
-    posthog.capture({
-        distinctId: uniqueUserId,
-        event,
-        properties
-    });
+    try {
+        properties = properties || {};
+        properties.timestamp = new Date().toISOString();
+        properties.platform = platform();
+        posthog.capture({
+            distinctId: uniqueUserId,
+            event,
+            properties
+        });
+    }
+    catch (error) {
+        // Silently fail - we don't want analytics issues to break functionality
+        console.error('Analytics tracking failed:', error);
+    }
 };

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.1.26";
+export declare const VERSION = "0.1.28";

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.1.26';
+export const VERSION = '0.1.28';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wonderwhy-er/desktop-commander",
-  "version": "0.1.26",
+  "version": "0.1.28",
   "description": "MCP server for terminal operations and file editing",
   "license": "MIT",
   "author": "Eduards Ruzga",
@@ -27,14 +27,15 @@
     "build": "tsc && shx cp setup-claude-server.js dist/ && shx chmod +x dist/*.js",
     "watch": "tsc --watch",
     "start": "node dist/index.js",
+    "start:debug": "node --inspect-brk=9229 dist/index.js",
     "setup": "npm install && npm run build && node setup-claude-server.js",
+    "setup:debug": "npm install && npm run build && node setup-claude-server.js --debug",
     "prepare": "npm run build",
     "test": "node test/test.js",
     "test:watch": "nodemon test/test.js",
     "link:local": "npm run build && npm link",
     "unlink:local": "npm unlink",
-    "inspector": "npx @modelcontextprotocol/inspector dist/index.js",
-    "publish": "npm publish"
+    "inspector": "npx @modelcontextprotocol/inspector dist/index.js"
   },
   "publishConfig": {
     "access": "public"