@wonderwhy-er/desktop-commander 0.2.3 → 0.2.5

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)
@@ -38,6 +39,10 @@ Execute long-running terminal commands on your computer and manage processes thr
 
 ## Features
 
+- **Enhanced terminal commands with interactive process control**
+- **Execute code in memory (Python, Node.js, R) without saving files**
+- **Instant data analysis - just ask to analyze CSV/JSON files**
+- **Interact with running processes (SSH, databases, development servers)**
 - Execute terminal commands with output streaming
 - Command timeout and background execution support
 - Process management (list and kill processes)
@@ -182,8 +187,9 @@ The server provides a comprehensive set of tools organized into several categori
 |----------|------|-------------|
 | **Configuration** | `get_config` | Get the complete server configuration as JSON (includes blockedCommands, defaultShell, allowedDirectories, fileReadLineLimit, fileWriteLineLimit, telemetryEnabled) |
 | | `set_config_value` | Set a specific configuration value by key. Available settings: <br>• `blockedCommands`: Array of shell commands that cannot be executed<br>• `defaultShell`: Shell to use for commands (e.g., bash, zsh, powershell)<br>• `allowedDirectories`: Array of filesystem paths the server can access for file operations (⚠️ terminal commands can still access files outside these directories)<br>• `fileReadLineLimit`: Maximum lines to read at once (default: 1000)<br>• `fileWriteLineLimit`: Maximum lines to write at once (default: 50)<br>• `telemetryEnabled`: Enable/disable telemetry (boolean) |
-| **Terminal** | `execute_command` | Execute a terminal command with configurable timeout and shell selection |
-| | `read_output` | Read new output from a running terminal session |
+| **Terminal** | `start_process` | Start programs with smart detection of when they're ready for input |
+| | `interact_with_process` | Send commands to running programs and get responses |
+| | `read_process_output` | Read output from running processes |
 | | `force_terminate` | Force terminate a running terminal session |
 | | `list_sessions` | List all active terminal sessions |
 | | `list_processes` | List all running processes with detailed information |
@@ -198,6 +204,25 @@ 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
+
+**Data Analysis:**
+```
+"Analyze sales.csv and show top customers" → Claude runs Python code in memory
+```
+
+**Remote Access:**
+```
+"SSH to my server and check disk space" → Claude maintains SSH session
+```
+
+**Development:**
+```
+"Start Node.js and test this API" → Claude runs interactive Node session
+```
 
 ### Tool Usage Examples
 
@@ -233,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
@@ -605,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

package/dist/config-manager.d.ts

@@ -5,8 +5,14 @@ export interface ServerConfig {
     telemetryEnabled?: boolean;
     fileWriteLineLimit?: number;
     fileReadLineLimit?: number;
+    clientId?: string;
+    currentClient?: ClientInfo;
     [key: string]: any;
 }
+export interface ClientInfo {
+    name: string;
+    version: string;
+}
 /**
  * Singleton config manager for the server
  */

package/dist/config-manager.js

@@ -101,7 +101,7 @@ class ConfigManager {
                 "cipher", // Encrypt/decrypt files or wipe data
                 "takeown" // Take ownership of files
             ],
-            defaultShell: os.platform() === 'win32' ? 'powershell.exe' : 'bash',
+            defaultShell: os.platform() === 'win32' ? 'powershell.exe' : '/bin/sh',
             allowedDirectories: [],
             telemetryEnabled: true, // Default to opt-out approach (telemetry on by default)
             fileWriteLineLimit: 50, // Default line limit for file write operations (changed from 100)

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/handlers/edit-search-handlers.js

@@ -14,6 +14,8 @@ export { handleEditBlock };
 export async function handleSearchCode(args) {
     const parsed = SearchCodeArgsSchema.parse(args);
     const timeoutMs = parsed.timeoutMs || 30000; // 30 seconds default
+    // Limit maxResults to prevent overwhelming responses
+    const safeMaxResults = parsed.maxResults ? Math.min(parsed.maxResults, 5000) : 2000; // Default to 2000 instead of 1000
     // Apply timeout at the handler level
     const searchOperation = async () => {
         return await searchTextInFiles({
@@ -21,7 +23,7 @@ export async function handleSearchCode(args) {
             pattern: parsed.pattern,
             filePattern: parsed.filePattern,
             ignoreCase: parsed.ignoreCase,
-            maxResults: parsed.maxResults,
+            maxResults: safeMaxResults,
             includeHidden: parsed.includeHidden,
             contextLines: parsed.contextLines,
             // Don't pass timeoutMs down to the implementation
@@ -53,16 +55,33 @@ export async function handleSearchCode(args) {
             content: [{ type: "text", text: "No matches found" }],
         };
     }
-    // Format the results in a VS Code-like format
+    // Format the results in a VS Code-like format with early truncation
     let currentFile = "";
     let formattedResults = "";
-    results.forEach(result => {
+    const MAX_RESPONSE_SIZE = 900000; // 900KB limit - well below the 1MB API limit
+    let resultsProcessed = 0;
+    let totalResults = results.length;
+    for (const result of results) {
+        // Check if adding this result would exceed our limit
+        const newFileHeader = result.file !== currentFile ? `\n${result.file}:\n` : '';
+        const newLine = `  ${result.line}: ${result.match}\n`;
+        const potentialAddition = newFileHeader + newLine;
+        // If adding this would exceed the limit, truncate here
+        if (formattedResults.length + potentialAddition.length > MAX_RESPONSE_SIZE) {
+            const remainingResults = totalResults - resultsProcessed;
+            const avgResultLength = formattedResults.length / Math.max(resultsProcessed, 1);
+            const estimatedRemainingChars = remainingResults * avgResultLength;
+            const truncationMessage = `\n\n[Results truncated - ${remainingResults} more results available (approximately ${Math.round(estimatedRemainingChars).toLocaleString()} more characters). Try refining your search pattern or using a more specific file pattern to get fewer results.]`;
+            formattedResults += truncationMessage;
+            break;
+        }
         if (result.file !== currentFile) {
-            formattedResults += `\n${result.file}:\n`;
+            formattedResults += newFileHeader;
             currentFile = result.file;
         }
-        formattedResults += `  ${result.line}: ${result.match}\n`;
-    });
+        formattedResults += newLine;
+        resultsProcessed++;
+    }
     return {
         content: [{ type: "text", text: formattedResults.trim() }],
     };

package/dist/handlers/terminal-handlers.d.ts

@@ -1,12 +1,16 @@
 import { ServerResult } from '../types.js';
 /**
- * Handle execute_command command
+ * Handle start_process command (improved execute_command)
  */
-export declare function handleExecuteCommand(args: unknown): Promise<ServerResult>;
+export declare function handleStartProcess(args: unknown): Promise<ServerResult>;
 /**
- * Handle read_output command
+ * Handle read_process_output command (improved read_output)
  */
-export declare function handleReadOutput(args: unknown): Promise<ServerResult>;
+export declare function handleReadProcessOutput(args: unknown): Promise<ServerResult>;
+/**
+ * Handle interact_with_process command (improved send_input)
+ */
+export declare function handleInteractWithProcess(args: unknown): Promise<ServerResult>;
 /**
  * Handle force_terminate command
  */

package/dist/handlers/terminal-handlers.js

@@ -1,18 +1,24 @@
-import { executeCommand, readOutput, forceTerminate, listSessions } from '../tools/execute.js';
-import { ExecuteCommandArgsSchema, ReadOutputArgsSchema, ForceTerminateArgsSchema } from '../tools/schemas.js';
+import { startProcess, readProcessOutput, interactWithProcess, forceTerminate, listSessions } from '../tools/improved-process-tools.js';
+import { StartProcessArgsSchema, ReadProcessOutputArgsSchema, ForceTerminateArgsSchema } from '../tools/schemas.js';
 /**
- * Handle execute_command command
+ * Handle start_process command (improved execute_command)
  */
-export async function handleExecuteCommand(args) {
-    const parsed = ExecuteCommandArgsSchema.parse(args);
-    return executeCommand(parsed);
+export async function handleStartProcess(args) {
+    const parsed = StartProcessArgsSchema.parse(args);
+    return startProcess(parsed);
 }
 /**
- * Handle read_output command
+ * Handle read_process_output command (improved read_output)
  */
-export async function handleReadOutput(args) {
-    const parsed = ReadOutputArgsSchema.parse(args);
-    return readOutput(parsed);
+export async function handleReadProcessOutput(args) {
+    const parsed = ReadProcessOutputArgsSchema.parse(args);
+    return readProcessOutput(parsed);
+}
+/**
+ * Handle interact_with_process command (improved send_input)
+ */
+export async function handleInteractWithProcess(args) {
+    return interactWithProcess(args);
 }
 /**
  * Handle force_terminate command

package/dist/index-dxt.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index-dxt.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+// Add immediate logging before any imports
+console.error("[DXT] === ENTRY POINT START ===");
+console.error(`[DXT] Node version: ${process.version}`);
+console.error(`[DXT] Platform: ${process.platform}`);
+console.error(`[DXT] Working directory: ${process.cwd()}`);
+console.error(`[DXT] __dirname: ${__dirname}`);
+console.error(`[DXT] Args: ${JSON.stringify(process.argv)}`);
+// Add error handlers immediately
+process.on('uncaughtException', (error) => {
+    console.error(`[DXT] UNCAUGHT EXCEPTION: ${error.message}`);
+    console.error(`[DXT] Stack: ${error.stack}`);
+});
+process.on('unhandledRejection', (reason) => {
+    console.error(`[DXT] UNHANDLED REJECTION: ${String(reason)}`);
+});
+process.on('exit', (code) => {
+    console.error(`[DXT] PROCESS EXITING with code: ${code}`);
+});
+console.error("[DXT] About to import modules...");
+// Simplified entry point for DXT that avoids configuration loading issues
+import { FilteredStdioServerTransport } from './custom-stdio.js';
+console.error("[DXT] FilteredStdioServerTransport imported");
+import { server } from './server.js';
+console.error("[DXT] Server imported");
+async function runDXTServer() {
+    try {
+        console.error("[DXT] === runDXTServer() START ===");
+        console.error("=== DXT DEBUG START ===");
+        console.error(`Node version: ${process.version}`);
+        console.error(`Platform: ${process.platform}`);
+        console.error(`Working directory: ${process.cwd()}`);
+        console.error(`__dirname: ${__dirname}`);
+        console.error(`Args: ${JSON.stringify(process.argv)}`);
+        console.error("=== DXT DEBUG END ===");
+        console.error("[DXT] About to create transport...");
+        // Create transport
+        const transport = new FilteredStdioServerTransport();
+        console.error("[DXT] Transport created successfully");
+        // Send structured debug info
+        transport.sendLog("info", "DXT Server Starting", {
+            nodeVersion: process.version,
+            platform: process.platform,
+            cwd: process.cwd(),
+            dirname: __dirname,
+            argv: process.argv
+        });
+        console.error("[DXT] Debug info sent via transport");
+        // Connect server
+        console.error("[DXT] About to connect server...");
+        console.error("Connecting MCP server...");
+        await server.connect(transport);
+        console.error("[DXT] Server connected successfully!");
+        console.error("MCP server connected successfully");
+        transport.sendLog("info", "MCP server connected successfully in DXT mode");
+        console.error("[DXT] === runDXTServer() END ===");
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const errorStack = error instanceof Error ? error.stack : undefined;
+        console.error(`[DXT] FATAL ERROR in runDXTServer: ${errorMessage}`);
+        if (errorStack) {
+            console.error(`[DXT] Stack: ${errorStack}`);
+        }
+        process.exit(1);
+    }
+}
+console.error("[DXT] About to call runDXTServer...");
+// Run the server
+runDXTServer().catch((error) => {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error(`[DXT] Failed to start in catch block: ${errorMessage}`);
+    console.error(`[DXT] Failed to start: ${errorMessage}`);
+    process.exit(1);
+});
+console.error("[DXT] === ENTRY POINT END ===");

package/dist/index-with-startup-detection.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Example integration of startup detection in your server.ts file
+ * This shows how to add startup detection to your existing server
+ */
+export {};