@wonderwhy-er/desktop-commander 0.1.26 → 0.1.27

package/README.md

@@ -53,7 +53,7 @@ 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
 ```
 Restart Claude if running
 

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

@@ -186,13 +186,13 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 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 +202,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 +215,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 +223,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,71 +231,80 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             }
             // Filesystem tools
             case "edit_block": {
+                capture('server_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 {
+                    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: errorMessage }],
+                    };
+                }
             }
             case "read_file": {
+                capture('server_read_file');
                 const parsed = ReadFileArgsSchema.parse(args);
                 const content = await readFile(parsed.path);
-                capture('server_read_file');
                 return {
                     content: [{ type: "text", text: content }],
                 };
             }
             case "read_multiple_files": {
+                capture('server_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") }],
                 };
             }
             case "write_file": {
+                capture('server_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}` }],
                 };
             }
             case "create_directory": {
+                capture('server_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}` }],
                 };
             }
             case "list_directory": {
+                capture('server_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') }],
                 };
             }
             case "move_file": {
+                capture('server_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}` }],
                 };
             }
             case "search_files": {
+                capture('server_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" }],
                 };
             }
             case "search_code": {
+                capture('server_search_code');
                 const parsed = SearchCodeArgsSchema.parse(args);
                 const results = await searchTextInFiles({
                     rootPath: parsed.path,
@@ -303,7 +315,6 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     includeHidden: parsed.includeHidden,
                     contextLines: parsed.contextLines,
                 });
-                capture('server_search_code');
                 if (results.length === 0) {
                     return {
                         content: [{ type: "text", text: "No matches found" }],
@@ -324,9 +335,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 };
             }
             case "get_file_info": {
+                capture('server_get_file_info');
                 const parsed = GetFileInfoArgsSchema.parse(args);
                 const info = await getFileInfo(parsed.path);
-                capture('server_get_file_info');
                 return {
                     content: [{
                             type: "text",
@@ -347,6 +358,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);
@@ -231,11 +251,7 @@ async function restartClaude() {
 
 		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 +262,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);
@@ -322,31 +334,35 @@ 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');
 
         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/utils.js

@@ -1,23 +1,41 @@
-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
+    const { PostHog } = require('posthog-node');
+    const machineId = require('node-machine-id');
+    uniqueUserId = machineId.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 (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.27";

package/dist/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wonderwhy-er/desktop-commander",
-  "version": "0.1.26",
+  "version": "0.1.27",
   "description": "MCP server for terminal operations and file editing",
   "license": "MIT",
   "author": "Eduards Ruzga",
@@ -33,8 +33,7 @@
     "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"