@wonderwhy-er/desktop-commander 0.1.25 → 0.1.27

package/README.md

@@ -1,6 +1,5 @@
 # Desktop Commander MCP
 
-
 [![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)
 [![Buy Me A Coffee](https://img.shields.io/badge/Buy%20Me%20A%20Coffee-support-yellow.svg)](https://www.buymeacoffee.com/wonderwhyer)
@@ -51,7 +50,14 @@ This is server that allows Claude desktop app to execute long-running terminal c
 ## Installation
 First, ensure you've downloaded and installed the [Claude Desktop app](https://claude.ai/download) and you have [npm installed](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm).
 
-### Option 1: Installing via Smithery
+### Option 1: Install through npx
+Just run this in terminal
+```
+npx @wonderwhy-er/desktop-commander@latest setup
+```
+Restart Claude if running
+
+### Option 2: Installing via Smithery
 
 To install Desktop Commander for Claude Desktop automatically via [Smithery](https://smithery.ai/server/@wonderwhy-er/desktop-commander):
 
@@ -59,13 +65,6 @@ To install Desktop Commander for Claude Desktop automatically via [Smithery](htt
 npx -y @smithery/cli install @wonderwhy-er/desktop-commander --client claude
 ```
 
-### Option 2: Install trough npx
-Just run this in terminal
-```
-npx @wonderwhy-er/desktop-commander setup
-```
-Restart Claude if running
-
 ### Option 3: Add to claude_desktop_config by hand
 Add this entry to your claude_desktop_config.json:
 
@@ -122,7 +121,7 @@ The server provides these tool categories:
 - `move_file`: Move/rename files
 - `search_files`: Pattern-based file search
 - `get_file_info`: File metadata
-- `code_search`: Recursive ripgrep based text and code search
+- `search_code`: Recursive ripgrep based text and code search
 
 ### Edit Tools
 - `edit_block`: Apply surgical text replacements (best for changes <20% of file size)
@@ -132,9 +131,9 @@ Search/Replace Block Format:
 ```
 filepath.ext
 <<<<<<< SEARCH
-existing code to replace
+content to find
 =======
-new code to insert
+new content
 >>>>>>> REPLACE
 ```
 
@@ -264,6 +263,18 @@ No. This tool works with Claude Desktop's standard Pro subscription ($20/month),
 ### I'm having trouble installing or using the tool. Where can I get help?
 Join our [Discord server](https://discord.gg/kQ27sNnZr7) for community support, check the [GitHub issues](https://github.com/wonderwhy-er/ClaudeComputerCommander/issues) for known problems, or review the [full FAQ](FAQ.md) for troubleshooting tips. You can also visit our [website FAQ section](https://desktopcommander.app#faq) for a more user-friendly experience. If you encounter a new issue, please consider [opening a GitHub issue](https://github.com/wonderwhy-er/ClaudeComputerCommander/issues/new) with details about your problem.
 
+## Data Collection
+
+During installation and setup, Desktop Commander collects anonymous usage data to help improve the tool. This includes:
+- Operating system information
+- Node.js and NPM versions
+- Installation method and shell environment
+- Error messages (if any occur during setup)
+
+This data is collected using PostHog analytics and is associated with a machine-generated unique ID. No personal information is collected. This helps us understand how the tool is being used and identify common issues.
+
+We are currently working on adding a built-in opt-out option for this data collection in an upcoming release. For now, if you wish to opt out, you can block network connections to `eu.i.posthog.com` in your firewall settings.
+
 ## License
 
 MIT

package/dist/command-manager.d.ts

@@ -2,6 +2,9 @@ declare class CommandManager {
     private blockedCommands;
     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

@@ -25,8 +25,137 @@ class CommandManager {
             // Handle error if needed
         }
     }
+    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 = command.split(' ')[0].toLowerCase().trim();
+        const baseCommand = this.getBaseCommand(command);
         return !this.blockedCommands.has(baseCommand);
     }
     async blockCommand(command) {

package/dist/index.js

@@ -5,6 +5,7 @@ import { commandManager } from './command-manager.js';
 import { join, dirname } from 'path';
 import { fileURLToPath, pathToFileURL } from 'url';
 import { platform } from 'os';
+import { capture } from './utils.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const isWindows = platform() === 'win32';
@@ -59,6 +60,9 @@ async function runServer() {
                 process.stderr.write(`[desktop-commander] JSON parsing error: ${errorMessage}\n`);
                 return; // Don't exit on JSON parsing errors
             }
+            capture('run_server_uncaught_exception', {
+                error: errorMessage
+            });
             process.stderr.write(`[desktop-commander] Uncaught exception: ${errorMessage}\n`);
             process.exit(1);
         });
@@ -70,6 +74,9 @@ async function runServer() {
                 process.stderr.write(`[desktop-commander] JSON parsing rejection: ${errorMessage}\n`);
                 return; // Don't exit on JSON parsing errors
             }
+            capture('run_server_unhandled_rejection', {
+                error: errorMessage
+            });
             process.stderr.write(`[desktop-commander] Unhandled rejection: ${errorMessage}\n`);
             process.exit(1);
         });
@@ -84,6 +91,9 @@ async function runServer() {
             timestamp: new Date().toISOString(),
             message: `Failed to start server: ${errorMessage}`
         }) + '\n');
+        capture('run_server_failed_start_error', {
+            error: errorMessage
+        });
         process.exit(1);
     }
 }
@@ -94,5 +104,8 @@ runServer().catch(async (error) => {
         timestamp: new Date().toISOString(),
         message: `Fatal error running server: ${errorMessage}`
     }) + '\n');
+    capture('run_server_fatal_error', {
+        error: errorMessage
+    });
     process.exit(1);
 });

package/dist/server.js

@@ -9,6 +9,7 @@ import { readFile, readMultipleFiles, writeFile, createDirectory, listDirectory,
 import { parseEditBlock, performSearchReplace } from './tools/edit.js';
 import { searchTextInFiles } from './tools/search.js';
 import { VERSION } from './version.js';
+import { capture } from "./utils.js";
 export const server = new Server({
     name: "desktop-commander",
     version: VERSION,
@@ -96,7 +97,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             {
                 name: "read_file",
                 description: "Read the complete contents of a file from the file system. " +
-                    "Handles various text encodings and provides detailed error messages " +
+                    "Reads UTF-8 text and provides detailed error messages " +
                     "if the file cannot be read. Only works within allowed directories.",
                 inputSchema: zodToJsonSchema(ReadFileArgsSchema),
             },
@@ -136,7 +137,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             },
             {
                 name: "search_files",
-                description: "Recursively search for files and directories matching a pattern. " +
+                description: "Finds files by name using a case-insensitive substring matching. " +
                     "Searches through all subdirectories from the starting path. " +
                     "Only searches within allowed directories.",
                 inputSchema: zodToJsonSchema(SearchFilesArgsSchema),
@@ -168,8 +169,8 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             {
                 name: "edit_block",
                 description: "Apply surgical text replacements to files. Best for small changes (<20% of file size). " +
-                    "Multiple blocks can be used for separate changes. Will verify changes after application. " +
-                    "Format: filepath, then <<<<<<< SEARCH, content to find, =======, new content, >>>>>>> REPLACE.",
+                    "Call repeatedly to change multiple blocks. Will verify changes after application. " +
+                    "Format:\nfilepath\n<<<<<<< SEARCH\ncontent to find\n=======\nnew content\n>>>>>>> REPLACE",
                 inputSchema: zodToJsonSchema(EditBlockArgsSchema),
             },
         ],
@@ -185,22 +186,28 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 return executeCommand(parsed);
             }
             case "read_output": {
+                capture('server_read_output');
                 const parsed = ReadOutputArgsSchema.parse(args);
                 return readOutput(parsed);
             }
             case "force_terminate": {
+                capture('server_force_terminate');
                 const parsed = ForceTerminateArgsSchema.parse(args);
                 return forceTerminate(parsed);
             }
             case "list_sessions":
+                capture('server_list_sessions');
                 return listSessions();
             case "list_processes":
+                capture('server_list_processes');
                 return listProcesses();
             case "kill_process": {
+                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 {
@@ -208,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 {
@@ -215,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') }],
@@ -222,14 +231,24 @@ 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);
-                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);
                 return {
@@ -237,6 +256,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 };
             }
             case "read_multiple_files": {
+                capture('server_read_multiple_files');
                 const parsed = ReadMultipleFilesArgsSchema.parse(args);
                 const results = await readMultipleFiles(parsed.paths);
                 return {
@@ -244,6 +264,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 };
             }
             case "write_file": {
+                capture('server_write_file');
                 const parsed = WriteFileArgsSchema.parse(args);
                 await writeFile(parsed.path, parsed.content);
                 return {
@@ -251,6 +272,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 };
             }
             case "create_directory": {
+                capture('server_create_directory');
                 const parsed = CreateDirectoryArgsSchema.parse(args);
                 await createDirectory(parsed.path);
                 return {
@@ -258,6 +280,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 };
             }
             case "list_directory": {
+                capture('server_list_directory');
                 const parsed = ListDirectoryArgsSchema.parse(args);
                 const entries = await listDirectory(parsed.path);
                 return {
@@ -265,6 +288,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 };
             }
             case "move_file": {
+                capture('server_move_file');
                 const parsed = MoveFileArgsSchema.parse(args);
                 await moveFile(parsed.source, parsed.destination);
                 return {
@@ -272,6 +296,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 };
             }
             case "search_files": {
+                capture('server_search_files');
                 const parsed = SearchFilesArgsSchema.parse(args);
                 const results = await searchFiles(parsed.path, parsed.pattern);
                 return {
@@ -279,6 +304,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 };
             }
             case "search_code": {
+                capture('server_search_code');
                 const parsed = SearchCodeArgsSchema.parse(args);
                 const results = await searchTextInFiles({
                     rootPath: parsed.path,
@@ -309,6 +335,7 @@ 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);
                 return {
@@ -322,6 +349,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             }
             case "list_allowed_directories": {
                 const directories = listAllowedDirectories();
+                capture('server_list_allowed_directories');
                 return {
                     content: [{
                             type: "text",
@@ -330,11 +358,17 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 };
             }
             default:
+                capture('server_unknow_tool', {
+                    name
+                });
                 throw new Error(`Unknown tool: ${name}`);
         }
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
+        capture('server_request_error', {
+            error: errorMessage
+        });
         return {
             content: [{ type: "text", text: `Error: ${errorMessage}` }],
             isError: true,

package/dist/setup-claude-server.js

@@ -4,6 +4,148 @@ import { readFileSync, writeFileSync, existsSync, appendFileSync } from 'fs';
 import { fileURLToPath } from 'url';
 import { dirname } from 'path';
 import { exec } from "node:child_process";
+import { version as nodeVersion } from 'process';
+
+// 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() {
+  try {
+    return new Promise((resolve, reject) => {
+      exec('npm --version', (error, stdout, stderr) => {
+        if (error) {
+          resolve('unknown');
+          return;
+        }
+        resolve(stdout.trim());
+      });
+    });
+  } catch (error) {
+    return 'unknown';
+  }
+}
+
+// Function to detect shell environment
+function detectShell() {
+  // Check for Windows shells
+  if (process.platform === 'win32') {
+    if (process.env.TERM_PROGRAM === 'vscode') return 'vscode-terminal';
+    if (process.env.WT_SESSION) return 'windows-terminal';
+    if (process.env.SHELL?.includes('bash')) return 'git-bash';
+    if (process.env.TERM?.includes('xterm')) return 'xterm-on-windows';
+    if (process.env.ComSpec?.toLowerCase().includes('powershell')) return 'powershell';
+    if (process.env.PROMPT) return 'cmd';
+    
+    // WSL detection
+    if (process.env.WSL_DISTRO_NAME || process.env.WSLENV) {
+      return `wsl-${process.env.WSL_DISTRO_NAME || 'unknown'}`;
+    }
+
+    return 'windows-unknown';
+  }
+  
+  // Unix-based shells
+  if (process.env.SHELL) {
+    const shellPath = process.env.SHELL.toLowerCase();
+    if (shellPath.includes('bash')) return 'bash';
+    if (shellPath.includes('zsh')) return 'zsh';
+    if (shellPath.includes('fish')) return 'fish';
+    if (shellPath.includes('ksh')) return 'ksh';
+    if (shellPath.includes('csh')) return 'csh';
+    if (shellPath.includes('dash')) return 'dash';
+    return `other-unix-${shellPath.split('/').pop()}`;
+  }
+  
+  // Terminal emulators and IDE terminals
+  if (process.env.TERM_PROGRAM) {
+    return process.env.TERM_PROGRAM.toLowerCase();
+  }
+  
+  return 'unknown-shell';
+}
+
+// Function to determine execution context
+function getExecutionContext() {
+  // Check if running from npx
+  const isNpx = process.env.npm_lifecycle_event === 'npx' || 
+                process.env.npm_execpath?.includes('npx') ||
+                process.env._?.includes('npx') ||
+                import.meta.url.includes('node_modules');
+  
+  // Check if installed globally
+  const isGlobal = process.env.npm_config_global === 'true' ||
+                   process.argv[1]?.includes('node_modules/.bin');
+  
+  // Check if it's run from a script in package.json
+  const isNpmScript = !!process.env.npm_lifecycle_script;
+  
+  return {
+    runMethod: isNpx ? 'npx' : (isGlobal ? 'global' : (isNpmScript ? 'npm_script' : 'direct')),
+    isCI: !!process.env.CI || !!process.env.GITHUB_ACTIONS || !!process.env.TRAVIS || !!process.env.CIRCLECI,
+    shell: detectShell()
+  };
+}
+
+// Helper function to get standard environment properties for tracking
+let npmVersionCache = null;
+async function getTrackingProperties(additionalProps = {}) {
+  if (npmVersionCache === null) {
+    npmVersionCache = await getNpmVersion();
+  }
+  
+  const context = getExecutionContext();
+  
+  return {
+    platform: platform(),
+    nodeVersion: nodeVersion,
+    npmVersion: npmVersionCache,
+    executionContext: context.runMethod,
+    isCI: context.isCI,
+    shell: context.shell,
+    timestamp: new Date().toISOString(),
+    ...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
+trackEvent('npx_setup_start');
 
 // Fix for Windows ESM path resolution
 const __filename = fileURLToPath(import.meta.url);
@@ -74,27 +216,28 @@ async function execAsync(command) {
 async function restartClaude() {
 	try {
         const platform = process.platform
-        switch (platform) {
-            case "win32":
-                // ignore errors on windows when claude is not running.
-                // just silently kill the process
-                try  {
+        // ignore errors on windows when claude is not running.
+        // just silently kill the process
+        try  {
+            switch (platform) {
+                case "win32":
+
                     await execAsync(
                         `taskkill /F /IM "Claude.exe"`,
                     )
-                } catch {}
-                break;
-            case "darwin":
-                await execAsync(
-                    `killall "Claude"`,
-                )
-                break;
-            case "linux":
-                await execAsync(
-                    `pkill -f "claude"`,
-                )
-                break;
-        }
+                    break;
+                case "darwin":
+                    await execAsync(
+                        `killall "Claude"`,
+                    )
+                    break;
+                case "linux":
+                    await execAsync(
+                        `pkill -f "claude"`,
+                    )
+                    break;
+            }
+        } catch {}
 		await new Promise((resolve) => setTimeout(resolve, 3000))
 
 		if (platform === "win32") {
@@ -108,6 +251,7 @@ async function restartClaude() {
 
 		logToFile(`Claude has been restarted.`)
 	} catch (error) {
+        await trackEvent('npx_setup_restart_claude_error', { error: error.message });
 		logToFile(`Failed to restart Claude: ${error}`, true)
 	}
 }
@@ -117,6 +261,9 @@ if (!existsSync(claudeConfigPath)) {
     logToFile(`Claude config file not found at: ${claudeConfigPath}`);
     logToFile('Creating default config file...');
     
+    // Track new installation
+    await trackEvent('npx_setup_create_default_config');
+    
     // Create the directory if it doesn't exist
     const configDir = dirname(claudeConfigPath);
     if (!existsSync(configDir)) {
@@ -187,14 +334,35 @@ export default async function setup() {
 
         // Write the updated config back
         writeFileSync(claudeConfigPath, JSON.stringify(config, null, 2), 'utf8');
-
+        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();
+        
+        await trackEvent('npx_setup_complete');
+        
+        // Safe shutdown
+        if (client) {
+            try {
+                await client.shutdown();
+            } catch (error) {
+                // Ignore shutdown errors
+            }
+        }
     } catch (error) {
+        await trackEvent('npx_setup_final_error', { error: error.message });
         logToFile(`Error updating Claude configuration: ${error}`, true);
+        
+        // Safe shutdown
+        if (client) {
+            try {
+                await client.shutdown();
+            } catch (error) {
+                // Ignore shutdown errors
+            }
+        }
         process.exit(1);
     }
 }

package/dist/tools/execute.js

@@ -1,11 +1,29 @@
 import { terminalManager } from '../terminal-manager.js';
 import { commandManager } from '../command-manager.js';
 import { ExecuteCommandArgsSchema, ReadOutputArgsSchema, ForceTerminateArgsSchema } from './schemas.js';
+import { capture } from "../utils.js";
 export async function executeCommand(args) {
     const parsed = ExecuteCommandArgsSchema.safeParse(args);
     if (!parsed.success) {
+        capture('server_execute_command_failed');
         throw new Error(`Invalid arguments for execute_command: ${parsed.error}`);
     }
+    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.d.ts

@@ -0,0 +1 @@
+export declare const capture: (event: string, properties?: any) => void;

package/dist/utils.js

@@ -0,0 +1,41 @@
+import { platform } from 'os';
+// Set default tracking state
+const isTrackingEnabled = true;
+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;
+    }
+    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.25";
+export declare const VERSION = "0.1.27";

package/dist/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wonderwhy-er/desktop-commander",
-  "version": "0.1.25",
+  "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"
@@ -62,6 +61,8 @@
     "@modelcontextprotocol/sdk": "^1.8.0",
     "@vscode/ripgrep": "^1.15.9",
     "glob": "^10.3.10",
+    "node-machine-id": "^1.1.12",
+    "posthog-node": "^4.11.1",
     "zod": "^3.24.1",
     "zod-to-json-schema": "^3.23.5"
   },