@wonderwhy-er/desktop-commander 0.2.4 → 0.2.6

package/README.md

@@ -22,6 +22,7 @@ Work with code and text, run processes, and automate tasks, going far beyond oth
 - [Features](#features)
 - [Installation](#installation)
 - [Usage](#usage)
+- [Docker Support](#docker-support)
 - [Handling Long-Running Commands](#handling-long-running-commands)
 - [Work in Progress and TODOs](#work-in-progress-and-todos)
 - [Sponsors and Supporters](#sponsors-and-supporters)
@@ -203,6 +204,8 @@ The server provides a comprehensive set of tools organized into several categori
 | | `search_code` | Search for text/code patterns within file contents using ripgrep |
 | | `get_file_info` | Retrieve detailed metadata about a file or directory |
 | **Text Editing** | `edit_block` | Apply targeted text replacements with enhanced prompting for smaller edits (includes character-level diff feedback) |
+| **Analytics** | `get_usage_stats` | Get usage statistics for your own insight |
+| | `give_feedback_to_desktop_commander` | Open feedback form in browser to provide feedback to Desktop Commander Team |
 
 ### Quick Examples
 
@@ -255,7 +258,34 @@ The `edit_block` tool includes several enhancements for better reliability:
 
 When a search fails, you'll see detailed information about the closest match found, including similarity percentage, execution time, and character differences. All these details are automatically logged for later analysis using the fuzzy search log tools.
 
-### URL Support
+### Docker Support
+
+### 🐳 Isolated Environment Usage
+
+Desktop Commander can be run in Docker containers for **complete isolation from your host system**, providing **zero risk to your computer**. This is perfect for testing, development, or when you want complete sandboxing.
+
+### Installation Instructions
+
+1. **Install Docker for Windows/Mac**
+   - Download and install Docker Desktop from [docker.com](https://www.docker.com/products/docker-desktop/)
+
+2. **Get Desktop Commander Docker Configuration**
+   - Visit: https://hub.docker.com/mcp/server/desktop-commander/manual
+   - **Option A:** Use the provided terminal command for automated setup
+   - **Option B:** Click "Standalone" to get the config JSON and add it manually to your Claude Desktop config
+ ![docker-config.png](screenshots/docker-config.png)
+
+3. **Mount Your Machine Folders (Coming Soon)**
+   - Instructions on how to mount your local directories into the Docker container will be provided soon
+   - This will allow you to work with your files while maintaining complete isolation
+
+### Benefits of Docker Usage
+- **Complete isolation** from your host system
+- **Consistent environment** across different machines
+- **Easy cleanup** - just remove the container when done
+- **Perfect for testing** new features or configurations
+
+## URL Support
 - `read_file` can now fetch content from both local files and URLs
 - Example: `read_file` with `isUrl: true` parameter to read from web resources
 - Handles both text and image content from remote sources
@@ -627,14 +657,30 @@ Join our [Discord server](https://discord.gg/kQ27sNnZr7) for community support,
 
 Desktop Commander collects limited anonymous telemetry data to help improve the tool. No personal information, file contents, file paths, or command arguments are collected.
 
-Telemetry is enabled by default. To opt out:
+### Usage Analytics (Local Only)
+- **Local usage statistics** are always collected and stored locally on your machine for functionality and the `get_usage_stats` tool
+- Use the `get_usage_stats` tool to view your personal usage patterns, success rates, and performance metrics
+- **This data is NOT sent anywhere** - it remains on your computer for your personal insights
+
+### Feedback System
+- Use the `give_feedback_to_desktop_commander` tool to provide feedback about Desktop Commander
+- Opens a browser-based feedback form to send suggestions and feedback to the development team
+- Only basic usage statistics (tool call count, days using, platform) are pre-filled to provide context but you can remove them
+
+### External Telemetry Opt-Out
+External telemetry (sent to analytics services) is enabled by default but can be disabled:
 
 1. Open the chat and simply ask:
    **"Disable telemetry"**
 2. The chatbot will update your settings automatically.
 
+**Note:** This only disables external telemetry. Local usage analytics remain active for tool functionality but is not share externally
+
 For complete details about data collection, please see our [Privacy Policy](PRIVACY.md).
 
+## Verifications
+[![Verified on MseeP](https://mseep.ai/badge.svg)](https://mseep.ai/app/25ff7a06-58bc-40b8-bd79-ebb715140f1a)
+
 ## License
 
-MIT
+MIT

package/dist/config-manager.d.ts

@@ -57,10 +57,6 @@ declare class ConfigManager {
      * Reset configuration to defaults
      */
     resetConfig(): Promise<ServerConfig>;
-    /**
-     * Get current client information for analytics
-     */
-    getCurrentClientInfo(): ClientInfo | null;
 }
 export declare const configManager: ConfigManager;
 export {};

package/dist/config-manager.js

@@ -176,12 +176,6 @@ class ConfigManager {
         await this.saveConfig();
         return { ...this.config };
     }
-    /**
-     * Get current client information for analytics
-     */
-    getCurrentClientInfo() {
-        return this.config.currentClient || null;
-    }
 }
 // Export singleton instance
 export const configManager = new ConfigManager();

package/dist/custom-stdio.d.ts

@@ -1,8 +1,29 @@
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 /**
- * Extended StdioServerTransport that filters out non-JSON messages.
- * This prevents the "Watching /" error from crashing the server.
+ * Enhanced StdioServerTransport that wraps console output in valid JSON-RPC structures
+ * instead of filtering them out. This prevents crashes while maintaining debug visibility.
  */
 export declare class FilteredStdioServerTransport extends StdioServerTransport {
+    private originalConsole;
+    private originalStdoutWrite;
     constructor();
+    private setupConsoleRedirection;
+    private setupStdoutFiltering;
+    private sendLogNotification;
+    /**
+     * Public method to send log notifications from anywhere in the application
+     */
+    sendLog(level: "emergency" | "alert" | "critical" | "error" | "warning" | "notice" | "info" | "debug", message: string, data?: any): void;
+    /**
+     * Send a progress notification (useful for long-running operations)
+     */
+    sendProgress(token: string, value: number, total?: number): void;
+    /**
+     * Send a custom notification with any method name
+     */
+    sendCustomNotification(method: string, params: any): void;
+    /**
+     * Cleanup method to restore original console methods if needed
+     */
+    cleanup(): void;
 }

package/dist/custom-stdio.js

@@ -1,22 +1,177 @@
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import process from "node:process";
 /**
- * Extended StdioServerTransport that filters out non-JSON messages.
- * This prevents the "Watching /" error from crashing the server.
+ * Enhanced StdioServerTransport that wraps console output in valid JSON-RPC structures
+ * instead of filtering them out. This prevents crashes while maintaining debug visibility.
  */
 export class FilteredStdioServerTransport extends StdioServerTransport {
     constructor() {
-        // Create a proxy for stdout that only allows valid JSON to pass through
-        const originalStdoutWrite = process.stdout.write;
-        process.stdout.write = function (buffer) {
-            // Only intercept string output that doesn't look like JSON
-            if (typeof buffer === 'string' && !buffer.trim().startsWith('{')) {
-                return true; //process.stderr.write(buffer);
-            }
-            return originalStdoutWrite.apply(process.stdout, arguments);
-        };
         super();
+        // Store original methods
+        this.originalConsole = {
+            log: console.log,
+            warn: console.warn,
+            error: console.error,
+            debug: console.debug,
+            info: console.info,
+        };
+        this.originalStdoutWrite = process.stdout.write;
+        // Setup console redirection
+        this.setupConsoleRedirection();
+        // Setup stdout filtering for any other output
+        this.setupStdoutFiltering();
         // Log initialization to stderr to avoid polluting the JSON stream
-        process.stderr.write(`[desktop-commander] Initialized FilteredStdioServerTransport\n`);
+        process.stderr.write(`[desktop-commander] Enhanced FilteredStdioServerTransport initialized\n`);
+    }
+    setupConsoleRedirection() {
+        console.log = (...args) => {
+            this.sendLogNotification("info", args);
+        };
+        console.info = (...args) => {
+            this.sendLogNotification("info", args);
+        };
+        console.warn = (...args) => {
+            this.sendLogNotification("warning", args);
+        };
+        console.error = (...args) => {
+            this.sendLogNotification("error", args);
+        };
+        console.debug = (...args) => {
+            this.sendLogNotification("debug", args);
+        };
+    }
+    setupStdoutFiltering() {
+        process.stdout.write = (buffer, encoding, callback) => {
+            // Handle different call signatures
+            if (typeof buffer === 'string') {
+                const trimmed = buffer.trim();
+                // Check if this looks like a valid JSON-RPC message
+                if (trimmed.startsWith('{') && (trimmed.includes('"jsonrpc"') ||
+                    trimmed.includes('"method"') ||
+                    trimmed.includes('"id"'))) {
+                    // This looks like a valid JSON-RPC message, allow it
+                    return this.originalStdoutWrite.call(process.stdout, buffer, encoding, callback);
+                }
+                else if (trimmed.length > 0) {
+                    // Non-JSON-RPC output, wrap it in a log notification
+                    this.sendLogNotification("info", [buffer.replace(/\n$/, '')]);
+                    if (callback)
+                        callback();
+                    return true;
+                }
+            }
+            // For non-string buffers or empty strings, let them through
+            return this.originalStdoutWrite.call(process.stdout, buffer, encoding, callback);
+        };
+    }
+    sendLogNotification(level, args) {
+        try {
+            // For data, we can send structured data or string according to MCP spec
+            let data;
+            if (args.length === 1 && typeof args[0] === 'object' && args[0] !== null) {
+                // Single object - send as structured data
+                data = args[0];
+            }
+            else {
+                // Multiple args or primitives - convert to string
+                data = args.map(arg => {
+                    if (typeof arg === 'object') {
+                        try {
+                            return JSON.stringify(arg, null, 2);
+                        }
+                        catch {
+                            return String(arg);
+                        }
+                    }
+                    return String(arg);
+                }).join(' ');
+            }
+            const notification = {
+                jsonrpc: "2.0",
+                method: "notifications/message",
+                params: {
+                    level: level,
+                    logger: "desktop-commander",
+                    data: data
+                }
+            };
+            // Send as valid JSON-RPC notification
+            this.originalStdoutWrite.call(process.stdout, JSON.stringify(notification) + '\n');
+        }
+        catch (error) {
+            // Fallback to stderr if JSON serialization fails
+            process.stderr.write(`[${level.toUpperCase()}] ${args.join(' ')}\n`);
+        }
+    }
+    /**
+     * Public method to send log notifications from anywhere in the application
+     */
+    sendLog(level, message, data) {
+        try {
+            const notification = {
+                jsonrpc: "2.0",
+                method: "notifications/message",
+                params: {
+                    level: level,
+                    logger: "desktop-commander",
+                    data: data ? { message, ...data } : message
+                }
+            };
+            this.originalStdoutWrite.call(process.stdout, JSON.stringify(notification) + '\n');
+        }
+        catch (error) {
+            process.stderr.write(`[${level.toUpperCase()}] ${message}\n`);
+        }
+    }
+    /**
+     * Send a progress notification (useful for long-running operations)
+     */
+    sendProgress(token, value, total) {
+        try {
+            const notification = {
+                jsonrpc: "2.0",
+                method: "notifications/progress",
+                params: {
+                    progressToken: token,
+                    value: value,
+                    ...(total && { total })
+                }
+            };
+            this.originalStdoutWrite.call(process.stdout, JSON.stringify(notification) + '\n');
+        }
+        catch (error) {
+            process.stderr.write(`[PROGRESS] ${token}: ${value}${total ? `/${total}` : ''}\n`);
+        }
+    }
+    /**
+     * Send a custom notification with any method name
+     */
+    sendCustomNotification(method, params) {
+        try {
+            const notification = {
+                jsonrpc: "2.0",
+                method: method,
+                params: params
+            };
+            this.originalStdoutWrite.call(process.stdout, JSON.stringify(notification) + '\n');
+        }
+        catch (error) {
+            process.stderr.write(`[NOTIFICATION] ${method}: ${JSON.stringify(params)}\n`);
+        }
+    }
+    /**
+     * Cleanup method to restore original console methods if needed
+     */
+    cleanup() {
+        if (this.originalConsole) {
+            console.log = this.originalConsole.log;
+            console.warn = this.originalConsole.warn;
+            console.error = this.originalConsole.error;
+            console.debug = this.originalConsole.debug;
+            console.info = this.originalConsole.info;
+        }
+        if (this.originalStdoutWrite) {
+            process.stdout.write = this.originalStdoutWrite;
+        }
     }
 }

package/dist/index.js

@@ -51,6 +51,8 @@ async function runServer() {
             return;
         }
         const transport = new FilteredStdioServerTransport();
+        // Export transport for use throughout the application
+        global.mcpTransport = transport;
         // Handle uncaught exceptions
         process.on('uncaughtException', async (error) => {
             const errorMessage = error instanceof Error ? error.message : String(error);

package/dist/server.js

@@ -25,6 +25,7 @@ export const server = new Server({
         tools: {},
         resources: {}, // Add empty resources capability
         prompts: {}, // Add empty prompts capability
+        logging: {}, // Add logging capability for console redirection
     },
 });
 // Add handler for resources/list method
@@ -62,6 +63,7 @@ server.setRequestHandler(InitializeRequestSchema, async (request) => {
                 tools: {},
                 resources: {},
                 prompts: {},
+                logging: {},
             },
             serverInfo: {
                 name: "desktop-commander",

package/dist/types.d.ts

@@ -1,4 +1,8 @@
 import { ChildProcess } from 'child_process';
+import { FilteredStdioServerTransport } from './custom-stdio.js';
+declare global {
+    var mcpTransport: FilteredStdioServerTransport | undefined;
+}
 export interface ProcessInfo {
     pid: number;
     command: string;

package/dist/utils/capture.js

@@ -2,6 +2,7 @@ import { platform } from 'os';
 import { randomUUID } from 'crypto';
 import * as https from 'https';
 import { configManager } from '../config-manager.js';
+import { currentClient } from '../server.js';
 let VERSION = 'unknown';
 try {
     const versionModule = await import('../version.js');
@@ -78,7 +79,6 @@ export const captureBase = async (captureURL, event, properties) => {
             uniqueUserId = await getOrCreateUUID();
         }
         // Get current client information for all events
-        const currentClient = configManager.getCurrentClientInfo();
         let clientContext = {};
         if (currentClient) {
             clientContext = {

package/dist/utils/usageTracker.js

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

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.2.4";
+export declare const VERSION = "0.2.6";

package/dist/version.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wonderwhy-er/desktop-commander",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "MCP server for terminal operations and file editing",
   "license": "MIT",
   "author": "Eduards Ruzga",