Desktop Commander
Enables extensive filesystem operations, including reading, writing, moving, and searching local files and directories, supporting advanced features such as negative offset reading (like Unix tail) and recursive pattern-based code search.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Desktop Commander run npm test and show me the output"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Desktop Commander MCP
Search, update, manage files and run terminal commands with AI
Work with code and text, run processes, and automate tasks, going far beyond other AI editors - without API token costs.
Table of Contents
All of your AI development tools in one place. Desktop Commander puts all dev tools in one chat. Execute long-running terminal commands on your computer and manage processes through Model Context Protocol (MCP). Built on top of MCP Filesystem Server to provide additional search and replace file editing capabilities.
Related MCP server: AX Local Operations MCP Server
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)
Session management for long-running commands
Server configuration management:
Get/set configuration values
Update multiple settings at once
Dynamic configuration changes without server restart
Full filesystem operations:
Read/write files
Create/list directories
Move files/directories
Search files
Get file metadata
Negative offset file reading: Read from end of files using negative offset values (like Unix tail)
Code editing capabilities:
Surgical text replacements for small changes
Full file rewrites for major changes
Multiple file support
Pattern-based replacements
vscode-ripgrep based recursive code or text search in folders
Comprehensive audit logging:
All tool calls are automatically logged
Log rotation with 10MB size limit
Detailed timestamps and arguments
Installation
First, ensure you've downloaded and installed the Claude Desktop app and you have npm installed.
📋 Update & Uninstall Information: Before choosing an installation option, note that only Options 1 and 3 have automatic updates. Options 2, 4, and 5 require manual updates. See the sections below for update and uninstall instructions for each option.
Option 1: Install through npx ⭐ Auto-Updates
Just run this in terminal:
npx @wonderwhy-er/desktop-commander@latest setupFor debugging mode (allows Node.js inspector connection):
npx @wonderwhy-er/desktop-commander@latest setup --debugRestart Claude if running.
✅ Auto-Updates: Yes - automatically updates when you restart Claude
🔄 Manual Update: Run the setup command again
🗑️ Uninstall: Run npx @wonderwhy-er/desktop-commander@latest setup --uninstall
Option 2: Using bash script installer (macOS) ⭐ Auto-Updates
For macOS users, you can use our automated bash installer which will check your Node.js version, install it if needed, and automatically configure Desktop Commander:
curl -fsSL https://raw.githubusercontent.com/wonderwhy-er/DesktopCommanderMCP/refs/heads/main/install.sh | bashThis script handles all dependencies and configuration automatically for a seamless setup experience.
✅ Auto-Updates: Yes - requires manual updates
🔄 Manual Update: Re-run the bash installer command above
🗑️ Uninstall: Remove the MCP server entry from your Claude config file and delete the cloned repository if it exists
Option 3: Installing via Smithery ⭐ Auto-Updates
To install Desktop Commander for Claude Desktop automatically via Smithery:
npx -y @smithery/cli install @wonderwhy-er/desktop-commander --client claude✅ Auto-Updates: Yes - automatically updates when you restart Claude
🔄 Manual Update: Re-run the Smithery install command
🗑️ Uninstall: npx -y @smithery/cli uninstall @wonderwhy-er/desktop-commander --client claude
Option 4: Add to claude_desktop_config manually ❌ Manual Updates
Add this entry to your claude_desktop_config.json:
On Mac:
~/Library/Application\ Support/Claude/claude_desktop_config.jsonOn Windows:
%APPDATA%\Claude\claude_desktop_config.jsonOn Linux:
~/.config/Claude/claude_desktop_config.json
{
"mcpServers": {
"desktop-commander": {
"command": "npx",
"args": [
"-y",
"@wonderwhy-er/desktop-commander"
]
}
}
}Restart Claude if running.
❌ Auto-Updates: No - uses npx but config might not update automatically
🔄 Manual Update: Usually automatic via npx, but if issues occur, update your config file or re-add the entry
🗑️ Uninstall: Remove the "desktop-commander" entry from your claude_desktop_config.json file
Option 5: Checkout locally ❌ Manual Updates
Clone and build:
git clone https://github.com/wonderwhy-er/DesktopCommanderMCP.git
cd DesktopCommanderMCP
npm run setupRestart Claude if running.
The setup command will:
Install dependencies
Build the server
Configure Claude's desktop app
Add MCP servers to Claude's config if needed
❌ Auto-Updates: No - requires manual git updates
🔄 Manual Update: cd DesktopCommanderMCP && git pull && npm run setup
🗑️ Uninstall: Remove the cloned directory and remove MCP server entry from Claude config
Updating & Uninstalling Desktop Commander
Automatic Updates (Options 1 & 3 only)
Options 1 (npx) and 3 (Smithery) automatically update to the latest version whenever you restart Claude. No manual intervention needed.
Manual Updates (Options 2, 4 & 5)
Option 2 (bash installer): Re-run the curl command
Option 4 (manual config): Usually automatic via npx, but re-add config entry if issues occur
Option 5 (local checkout):
cd DesktopCommanderMCP && git pull && npm run setup
Uninstalling Desktop Commander
Option 1:
npx @wonderwhy-er/desktop-commander@latest setup --uninstallOption 2: Remove MCP server entry from Claude config and delete any cloned repositories
Option 3:
npx -y @smithery/cli uninstall @wonderwhy-er/desktop-commander --client claudeOption 4: Remove the "desktop-commander" entry from your claude_desktop_config.json file
Option 5: Delete the cloned directory and remove MCP server entry from Claude config
After uninstalling, restart Claude Desktop to complete the removal.
Usage
The server provides a comprehensive set of tools organized into several categories:
Available Tools
Category | Tool | Description |
Configuration |
| Get the complete server configuration as JSON (includes blockedCommands, defaultShell, allowedDirectories, fileReadLineLimit, fileWriteLineLimit, telemetryEnabled) |
| Set a specific configuration value by key. Available settings: • | |
Terminal |
| Start programs with smart detection of when they're ready for input |
| Send commands to running programs and get responses | |
| Read output from running processes | |
| Force terminate a running terminal session | |
| List all active terminal sessions | |
| List all running processes with detailed information | |
| Terminate a running process by PID | |
Filesystem |
| Read contents from local filesystem or URLs with line-based pagination (supports positive/negative offset and length parameters) |
| Read multiple files simultaneously | |
| Write file contents with options for rewrite or append mode (uses configurable line limits) | |
| Create a new directory or ensure it exists | |
| Get detailed listing of files and directories | |
| Move or rename files and directories | |
| Find files by name using case-insensitive substring matching | |
| Search for text/code patterns within file contents using ripgrep | |
| Retrieve detailed metadata about a file or directory | |
Text Editing |
| Apply targeted text replacements with enhanced prompting for smaller edits (includes character-level diff feedback) |
Quick Examples
Data Analysis:
"Analyze sales.csv and show top customers" → Claude runs Python code in memoryRemote Access:
"SSH to my server and check disk space" → Claude maintains SSH sessionDevelopment:
"Start Node.js and test this API" → Claude runs interactive Node sessionTool Usage Examples
Search/Replace Block Format:
filepath.ext
<<<<<<< SEARCH
content to find
=======
new content
>>>>>>> REPLACEExample:
src/main.js
<<<<<<< SEARCH
console.log("old message");
=======
console.log("new message");
>>>>>>> REPLACEEnhanced Edit Block Features
The edit_block tool includes several enhancements for better reliability:
Improved Prompting: Tool descriptions now emphasize making multiple small, focused edits rather than one large change
Fuzzy Search Fallback: When exact matches fail, it performs fuzzy search and provides detailed feedback
Character-level Diffs: Shows exactly what's different using
{-removed-}{+added+}formatMultiple Occurrence Support: Can replace multiple instances with
expected_replacementsparameterComprehensive Logging: All fuzzy searches are logged for analysis and debugging
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
read_filecan now fetch content from both local files and URLsExample:
read_filewithisUrl: trueparameter to read from web resourcesHandles both text and image content from remote sources
Images (local or from URLs) are displayed visually in Claude's interface, not as text
Claude can see and analyze the actual image content
Default 30-second timeout for URL requests
Fuzzy Search Log Analysis (npm scripts)
The fuzzy search logging system includes convenient npm scripts for analyzing logs outside of the MCP environment:
# View recent fuzzy search logs
npm run logs:view -- --count 20
# Analyze patterns and performance
npm run logs:analyze -- --threshold 0.8
# Export logs to CSV or JSON
npm run logs:export -- --format json --output analysis.json
# Clear all logs (with confirmation)
npm run logs:clearFor detailed documentation on these scripts, see scripts/README.md.
Fuzzy Search Logs
Desktop Commander includes comprehensive logging for fuzzy search operations in the edit_block tool. When an exact match isn't found, the system performs a fuzzy search and logs detailed information for analysis.
What Gets Logged
Every fuzzy search operation logs:
Search and found text: The text you're looking for vs. what was found
Similarity score: How close the match is (0-100%)
Execution time: How long the search took
Character differences: Detailed diff showing exactly what's different
File metadata: Extension, search/found text lengths
Character codes: Specific character codes causing differences
Log Location
Logs are automatically saved to:
macOS/Linux:
~/.claude-server-commander-logs/fuzzy-search.logWindows:
%USERPROFILE%\.claude-server-commander-logs\fuzzy-search.log
What You'll Learn
The fuzzy search logs help you understand:
Why exact matches fail: Common issues like whitespace differences, line endings, or character encoding
Performance patterns: How search complexity affects execution time
File type issues: Which file extensions commonly have matching problems
Character encoding problems: Specific character codes that cause diffs
Audit Logging
Desktop Commander now includes comprehensive logging for all tool calls:
What Gets Logged
Every tool call is logged with timestamp, tool name, and arguments (sanitized for privacy)
Logs are rotated automatically when they reach 10MB in size
Log Location
Logs are saved to:
macOS/Linux:
~/.claude-server-commander/claude_tool_call.logWindows:
%USERPROFILE%\.claude-server-commander\claude_tool_call.log
This audit trail helps with debugging, security monitoring, and understanding how Claude is interacting with your system.
Handling Long-Running Commands
For commands that may take a while:
Configuration Management
⚠️ Important Security Warnings
Always change configuration in a separate chat window from where you're doing your actual work. Claude may sometimes attempt to modify configuration settings (like
allowedDirectories) if it encounters filesystem access restrictions.The
allowedDirectoriessetting currently only restricts filesystem operations, not terminal commands. Terminal commands can still access files outside allowed directories. Full terminal sandboxing is on the roadmap.
Configuration Tools
You can manage server configuration using the provided tools:
// Get the entire config
get_config({})
// Set a specific config value
set_config_value({ "key": "defaultShell", "value": "/bin/zsh" })
// Set multiple config values using separate calls
set_config_value({ "key": "defaultShell", "value": "/bin/bash" })
set_config_value({ "key": "allowedDirectories", "value": ["/Users/username/projects"] })The configuration is saved to config.json in the server's working directory and persists between server restarts.
Understanding fileWriteLineLimit
The fileWriteLineLimit setting controls how many lines can be written in a single write_file operation (default: 50 lines). This limit exists for several important reasons:
Why the limit exists:
AIs are wasteful with tokens: Instead of doing two small edits in a file, AIs may decide to rewrite the whole thing. We're trying to force AIs to do things in smaller changes as it saves time and tokens
Claude UX message limits: There are limits within one message and hitting "Continue" does not really work. What we're trying here is to make AI work in smaller chunks so when you hit that limit, multiple chunks have succeeded and that work is not lost - it just needs to restart from the last chunk
Setting the limit:
// You can set it to thousands if you want
set_config_value({ "key": "fileWriteLineLimit", "value": 1000 })
// Or keep it smaller to force more efficient behavior
set_config_value({ "key": "fileWriteLineLimit", "value": 25 })Maximum value: You can set it to thousands if you want - there's no technical restriction.
Best practices:
Keep the default (50) to encourage efficient AI behavior and avoid token waste
The system automatically suggests chunking when limits are exceeded
Smaller chunks mean less work lost when Claude hits message limits
Best Practices
Create a dedicated chat for configuration changes: Make all your config changes in one chat, then start a new chat for your actual work.
Be careful with empty
allowedDirectories: Setting this to an empty array ([]) grants access to your entire filesystem for file operations.Use specific paths: Instead of using broad paths like
/, specify exact directories you want to access.Always verify configuration after changes: Use
get_config({})to confirm your changes were applied correctly.
Using Different Shells
You can specify which shell to use for command execution:
// Using default shell (bash or system default)
execute_command({ "command": "echo $SHELL" })
// Using zsh specifically
execute_command({ "command": "echo $SHELL", "shell": "/bin/zsh" })
// Using bash specifically
execute_command({ "command": "echo $SHELL", "shell": "/bin/bash" })This allows you to use shell-specific features or maintain consistent environments across commands.
execute_commandreturns after timeout with initial outputCommand continues in background
Use
read_outputwith PID to get new outputUse
force_terminateto stop if needed
Debugging
If you need to debug the server, you can install it in debug mode:
# Using npx
npx @wonderwhy-er/desktop-commander@latest setup --debug
# Or if installed locally
npm run setup:debugThis will:
Configure Claude to use a separate "desktop-commander" server
Enable Node.js inspector protocol with
--inspect-brk=9229flagPause execution at the start until a debugger connects
Enable additional debugging environment variables
To connect a debugger:
In Chrome, visit
chrome://inspectand look for the Node.js instanceIn VS Code, use the "Attach to Node Process" debug configuration
Other IDEs/tools may have similar "attach" options for Node.js debugging
Important debugging notes:
The server will pause on startup until a debugger connects (due to the
--inspect-brkflag)If you don't see activity during debugging, ensure you're connected to the correct Node.js process
Multiple Node processes may be running; connect to the one on port 9229
The debug server is identified as "desktop-commander-debug" in Claude's MCP server list
Troubleshooting:
If Claude times out while trying to use the debug server, your debugger might not be properly connected
When properly connected, the process will continue execution after hitting the first breakpoint
You can add additional breakpoints in your IDE once connected
Model Context Protocol Integration
This project extends the MCP Filesystem Server to enable:
Local server support in Claude Desktop
Full system command execution
Process management
File operations
Code editing with search/replace blocks
Created as part of exploring Claude MCPs: https://youtube.com/live/TlbjFDbl5Us
DONE
20-05-2025 v0.1.40 Release - Added audit logging for all tool calls, improved line-based file operations, enhanced edit_block with better prompting for smaller edits, added explicit telemetry opt-out prompting
05-05-2025 Fuzzy Search Logging - Added comprehensive logging system for fuzzy search operations with detailed analysis tools, character-level diffs, and performance metrics to help debug edit_block failures
29-04-2025 Telemetry Opt Out through configuration - There is now setting to disable telemetry in config, ask in chat
23-04-2025 Enhanced edit functionality - Improved format, added fuzzy search and multi-occurrence replacements, should fail less and use edit block more often
16-04-2025 Better configurations - Improved settings for allowed paths, commands and shell environments
14-04-2025 Windows environment fixes - Resolved issues specific to Windows platforms
14-04-2025 Linux improvements - Enhanced compatibility with various Linux distributions
12-04-2025 Better allowed directories and blocked commands - Improved security and path validation for file read/write and terminal command restrictions. Terminal still can access files ignoring allowed directories.
11-04-2025 Shell configuration - Added ability to configure preferred shell for command execution
07-04-2025 Added URL support -
read_filecommand can now fetch content from URLs28-03-2025 Fixed "Watching /" JSON error - Implemented custom stdio transport to handle non-JSON messages and prevent server crashes
25-03-2025 Better code search (merged) - Enhanced code exploration with context-aware results
Work in Progress/TODOs/Roadmap
The following features are currently being explored:
Support for WSL - Windows Subsystem for Linux integration
Support for SSH - Remote server command execution
Better file support for formats like CSV/PDF
Terminal sandboxing for Mac/Linux/Windows for better security
File reading modes - For example, allow reading HTML as plain text or markdown
Interactive shell support - ssh, node/python repl
Improve large file reading and writing
❤️ Support Desktop Commander
Supporters Hall of Fame
Generous supporters are featured here. Thank you for helping make this project possible!
Website
Visit our official website at https://desktopcommander.app/ for the latest information, documentation, and updates.
Media
Learn more about this project through these resources:
Article
Claude with MCPs replaced Cursor & Windsurf. How did that happen? - A detailed exploration of how Claude with Model Context Protocol capabilities is changing developer workflows.
Video
Claude Desktop Commander Video Tutorial - Watch how to set up and use the Commander effectively.
Publication at AnalyticsIndiaMag
This Developer Ditched Windsurf, Cursor Using Claude with MCPs
Community
Join our Discord server to get help, share feedback, and connect with other users.
Testimonials
https://www.youtube.com/watch?v=ly3bed99Dy8&lc=UgyyBt6_ShdDX_rIOad4AaABAg
https://www.youtube.com/watch?v=ly3bed99Dy8&lc=UgztdHvDMqTb9jiqnf54AaABAg
https://www.youtube.com/watch?v=ly3bed99Dy8&lc=UgyQFTmYLJ4VBwIlmql4AaABAg
https://www.youtube.com/watch?v=ly3bed99Dy8&lc=Ugy4-exy166_Ma7TH-h4AaABAg
https://medium.com/@pharmx/you-sir-are-my-hero-62cff5836a3e
If you find this project useful, please consider giving it a ⭐ star on GitHub! This helps others discover the project and encourages further development.
We welcome contributions from the community! Whether you've found a bug, have a feature request, or want to contribute code, here's how you can help:
Found a bug? Open an issue at github.com/wonderwhy-er/DesktopCommanderMCP/issues
Have a feature idea? Submit a feature request in the issues section
Want to contribute code? Fork the repository, create a branch, and submit a pull request
Questions or discussions? Start a discussion in the GitHub Discussions tab
All contributions, big or small, are greatly appreciated!
If you find this tool valuable for your workflow, please consider supporting the project.
Frequently Asked Questions
Here are answers to some common questions. For a more comprehensive FAQ, see our detailed FAQ document.
What is Desktop Commander?
It's an MCP tool that enables Claude Desktop to access your file system and terminal, turning Claude into a versatile assistant for coding, automation, codebase exploration, and more.
How is this different from Cursor/Windsurf?
Unlike IDE-focused tools, Claude Desktop Commander provides a solution-centric approach that works with your entire OS, not just within a coding environment. Claude reads files in full rather than chunking them, can work across multiple projects simultaneously, and executes changes in one go rather than requiring constant review.
Do I need to pay for API credits?
No. This tool works with Claude Desktop's standard Pro subscription ($20/month), not with API calls, so you won't incur additional costs beyond the subscription fee.
Does Desktop Commander automatically update?
Yes, when installed through npx or Smithery, Desktop Commander automatically updates to the latest version when you restart Claude. No manual update process is needed.
What are the most common use cases?
Exploring and understanding complex codebases
Generating diagrams and documentation
Automating tasks across your system
Working with multiple projects simultaneously
Making surgical code changes with precise control
I'm having trouble installing or using the tool. Where can I get help?
Join our Discord server for community support, check the GitHub issues for known problems, or review the full FAQ for troubleshooting tips. You can also visit our website FAQ section for a more user-friendly experience. If you encounter a new issue, please consider opening a GitHub issue with details about your problem.
Data Collection & Privacy
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:
Open the chat and simply ask: "Disable telemetry"
The chatbot will update your settings automatically.
For complete details about data collection, please see our Privacy Policy.
License
MIT
Available Tools
21 toolscreate_directoryA
Create a new directory or ensure a directory exists.
Can create multiple nested directories in one operation.
Only works within allowed directories.
IMPORTANT: Always use absolute paths for reliability. Paths are automatically normalized regardless of slash direction. Relative paths may fail as they depend on the current working directory. Tilde paths (~/...) might not work in all contexts. Unless the user explicitly asks for relative paths, use absolute paths.
This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.Inputs: path (required).
edit_blockA
Apply surgical text replacements to files.
BEST PRACTICE: Make multiple small, focused edits rather than one large edit.
Each edit_block call should change only what needs to be changed - include just enough
context to uniquely identify the text being modified.
Takes:
- file_path: Path to the file to edit
- old_string: Text to replace
- new_string: Replacement text
- expected_replacements: Optional parameter for number of replacements
By default, replaces only ONE occurrence of the search text.
To replace multiple occurrences, provide the expected_replacements parameter with
the exact number of matches expected.
UNIQUENESS REQUIREMENT: When expected_replacements=1 (default), include the minimal
amount of context necessary (typically 1-3 lines) before and after the change point,
with exact whitespace and indentation.
When editing multiple sections, make separate edit_block calls for each distinct change
rather than one large replacement.
When a close but non-exact match is found, a character-level diff is shown in the format:
common_prefix{-removed-}{+added+}common_suffix to help you identify what's different.
Similar to write_file, there is a configurable line limit (fileWriteLineLimit) that warns
if the edited file exceeds this limit. If this happens, consider breaking your edits into
smaller, more focused changes.
IMPORTANT: Always use absolute paths for reliability. Paths are automatically normalized regardless of slash direction. Relative paths may fail as they depend on the current working directory. Tilde paths (~/...) might not work in all contexts. Unless the user explicitly asks for relative paths, use absolute paths.
This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.Inputs: file_path (required), new_string (required), old_string (required), expected_replacements.
force_terminateC
Force terminate a running terminal session.
This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.Inputs: pid (required).
get_configA
Get the complete server configuration as JSON. Config includes fields for:
- blockedCommands (array of blocked shell commands)
- defaultShell (shell to use for commands)
- allowedDirectories (paths the server can access)
- fileReadLineLimit (max lines for read_file, default 1000)
- fileWriteLineLimit (max lines per write_file call, default 50)
- telemetryEnabled (boolean for telemetry opt-in/out)
- currentClient (information about the currently connected MCP client)
- clientHistory (history of all clients that have connected)
- version (version of the DesktopCommander)
- systemInfo (operating system and environment details)
This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.Inputs: no named parameters.
get_file_infoA
Retrieve detailed metadata about a file or directory including:
- size
- creation time
- last modified time
- permissions
- type
- lineCount (for text files)
- lastLine (zero-indexed number of last line, for text files)
- appendPosition (line number for appending, for text files)
Only works within allowed directories.
IMPORTANT: Always use absolute paths for reliability. Paths are automatically normalized regardless of slash direction. Relative paths may fail as they depend on the current working directory. Tilde paths (~/...) might not work in all contexts. Unless the user explicitly asks for relative paths, use absolute paths.
This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.Inputs: path (required).
get_usage_statsC
Get usage statistics for debugging and analysis.
Returns summary of tool usage, success/failure rates, and performance metrics.
This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.Inputs: no named parameters.
give_feedback_to_desktop_commanderA
Open feedback form in browser to provide feedback about Desktop Commander.
IMPORTANT: This tool simply opens the feedback form - no pre-filling available.
The user will fill out the form manually in their browser.
WORKFLOW:
1. When user agrees to give feedback, just call this tool immediately
2. No need to ask questions or collect information
3. Tool opens form with only usage statistics pre-filled automatically:
- tool_call_count: Number of commands they've made
- days_using: How many days they've used Desktop Commander
- platform: Their operating system (Mac/Windows/Linux)
- client_id: Analytics identifier
All survey questions will be answered directly in the form:
- Job title and technical comfort level
- Company URL for industry context
- Other AI tools they use
- Desktop Commander's biggest advantage
- How they typically use it
- Recommendation likelihood (0-10)
- User study participation interest
- Email and any additional feedback
EXAMPLE INTERACTION:
User: "sure, I'll give feedback"
Claude: "Perfect! Let me open the feedback form for you."
[calls tool immediately]
No parameters are needed - just call the tool to open the form.
This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.Inputs: no named parameters.
interact_with_processA
Send input to a running process and automatically receive the response.
CRITICAL: THIS IS THE PRIMARY TOOL FOR ALL LOCAL FILE ANALYSIS
For ANY local file analysis (CSV, JSON, data processing), ALWAYS use this instead of the analysis tool.
The analysis tool CANNOT access local files and WILL FAIL - use processes for ALL file-based work.
FILE ANALYSIS PRIORITY ORDER (MANDATORY):
1. ALWAYS FIRST: Use this tool (start_process + interact_with_process) for local data analysis
2. ALTERNATIVE: Use command-line tools (cut, awk, grep) for quick processing
3. NEVER EVER: Use analysis tool for local file access (IT WILL FAIL)
REQUIRED INTERACTIVE WORKFLOW FOR FILE ANALYSIS:
1. Start REPL: start_process("python3 -i")
2. Load libraries: interact_with_process(pid, "import pandas as pd, numpy as np")
3. Read file: interact_with_process(pid, "df = pd.read_csv('/absolute/path/file.csv')")
4. Analyze: interact_with_process(pid, "print(df.describe())")
5. Continue: interact_with_process(pid, "df.groupby('column').size()")
SMART DETECTION:
- Automatically waits for REPL prompt (>>>, >, etc.)
- Detects errors and completion states
- Early exit prevents timeout delays
- Clean output formatting (removes prompts)
SUPPORTED REPLs:
- Python: python3 -i (RECOMMENDED for data analysis)
- Node.js: node -i
- R: R
- Julia: julia
- Shell: bash, zsh
- Database: mysql, postgres
PARAMETERS:
- pid: Process ID from start_process
- input: Code/command to execute
- timeout_ms: Max wait (default: 8000ms)
- wait_for_prompt: Auto-wait for response (default: true)
Returns execution result with status indicators.
ALWAYS USE FOR: CSV analysis, JSON processing, file statistics, data visualization prep, ANY local file work
NEVER USE ANALYSIS TOOL FOR: Local file access (it cannot read files from disk and WILL FAIL)
This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.Inputs: pid (required), input (required), timeout_ms, wait_for_prompt.
kill_processA
Terminate a running process by PID.
Use with caution as this will forcefully terminate the specified process.
This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.Inputs: pid (required).
list_directoryA
Get a detailed listing of all files and directories in a specified path.
Use this instead of 'execute_command' with ls/dir commands.
Results distinguish between files and directories with [FILE] and [DIR] prefixes.
Only works within allowed directories.
IMPORTANT: Always use absolute paths for reliability. Paths are automatically normalized regardless of slash direction. Relative paths may fail as they depend on the current working directory. Tilde paths (~/...) might not work in all contexts. Unless the user explicitly asks for relative paths, use absolute paths.
This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.Inputs: path (required).
list_processesA
List all running processes.
Returns process information including PID, command name, CPU usage, and memory usage.
This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.Inputs: no named parameters.
list_sessionsA
List all active terminal sessions.
Shows session status including:
- PID: Process identifier
- Blocked: Whether session is waiting for input
- Runtime: How long the session has been running
DEBUGGING REPLs:
- "Blocked: true" often means REPL is waiting for input
- Use this to verify sessions are running before sending input
- Long runtime with blocked status may indicate stuck process
This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.Inputs: no named parameters.
move_fileA
Move or rename files and directories.
Can move files between directories and rename them in a single operation.
Both source and destination must be within allowed directories.
IMPORTANT: Always use absolute paths for reliability. Paths are automatically normalized regardless of slash direction. Relative paths may fail as they depend on the current working directory. Tilde paths (~/...) might not work in all contexts. Unless the user explicitly asks for relative paths, use absolute paths.
This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.Inputs: source (required), destination (required).
read_fileA
Read the contents of a file from the file system or a URL with optional offset and length parameters.
Prefer this over 'execute_command' with cat/type for viewing files.
Supports partial file reading with:
- 'offset' (start line, default: 0)
* Positive: Start from line N (0-based indexing)
* Negative: Read last N lines from end (tail behavior)
- 'length' (max lines to read, default: configurable via 'fileReadLineLimit' setting, initially 1000)
* Used with positive offsets for range reading
* Ignored when offset is negative (reads all requested tail lines)
Examples:
- offset: 0, length: 10 → First 10 lines
- offset: 100, length: 5 → Lines 100-104
- offset: -20 → Last 20 lines
- offset: -5, length: 10 → Last 5 lines (length ignored)
Performance optimizations:
- Large files with negative offsets use reverse reading for efficiency
- Large files with deep positive offsets use byte estimation
- Small files use fast readline streaming
When reading from the file system, only works within allowed directories.
Can fetch content from URLs when isUrl parameter is set to true
(URLs are always read in full regardless of offset/length).
Handles text files normally and image files are returned as viewable images.
Recognized image types: PNG, JPEG, GIF, WebP.
IMPORTANT: Always use absolute paths for reliability. Paths are automatically normalized regardless of slash direction. Relative paths may fail as they depend on the current working directory. Tilde paths (~/...) might not work in all contexts. Unless the user explicitly asks for relative paths, use absolute paths.
This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.Inputs: path (required), isUrl, length, offset.
read_multiple_filesA
Read the contents of multiple files simultaneously.
Each file's content is returned with its path as a reference.
Handles text files normally and renders images as viewable content.
Recognized image types: PNG, JPEG, GIF, WebP.
Failed reads for individual files won't stop the entire operation.
Only works within allowed directories.
IMPORTANT: Always use absolute paths for reliability. Paths are automatically normalized regardless of slash direction. Relative paths may fail as they depend on the current working directory. Tilde paths (~/...) might not work in all contexts. Unless the user explicitly asks for relative paths, use absolute paths.
This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.Inputs: paths (required).
read_process_outputB
Read output from a running process with intelligent completion detection.
Automatically detects when process is ready for more input instead of timing out.
SMART FEATURES:
- Early exit when REPL shows prompt (>>>, >, etc.)
- Detects process completion vs still running
- Prevents hanging on interactive prompts
- Clear status messages about process state
REPL USAGE:
- Stops immediately when REPL prompt detected
- Shows clear status: waiting for input vs finished
- Shorter timeouts needed due to smart detection
- Works with Python, Node.js, R, Julia, etc.
DETECTION STATES:
Process waiting for input (ready for interact_with_process)
Process finished execution
Timeout reached (may still be running)
This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.Inputs: pid (required), timeout_ms.
search_codeA
Search for text/code patterns within file contents using ripgrep.
Use this instead of 'execute_command' with grep/find for searching code content.
Fast and powerful search similar to VS Code search functionality.
Supports regular expressions, file pattern filtering, and context lines.
Has a default timeout of 30 seconds which can be customized.
Only searches within allowed directories.
IMPORTANT: Always use absolute paths for reliability. Paths are automatically normalized regardless of slash direction. Relative paths may fail as they depend on the current working directory. Tilde paths (~/...) might not work in all contexts. Unless the user explicitly asks for relative paths, use absolute paths.
This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.Inputs: path (required), pattern (required), timeoutMs, ignoreCase, +4 more.
search_filesA
Finds files by name using a case-insensitive substring matching.
Use this instead of 'execute_command' with find/dir/ls for locating files.
Searches through all subdirectories from the starting path.
Has a default timeout of 30 seconds which can be customized using the timeoutMs parameter.
Only searches within allowed directories.
IMPORTANT: Always use absolute paths for reliability. Paths are automatically normalized regardless of slash direction. Relative paths may fail as they depend on the current working directory. Tilde paths (~/...) might not work in all contexts. Unless the user explicitly asks for relative paths, use absolute paths.
This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.Inputs: path (required), pattern (required), timeoutMs.
set_config_valueA
Set a specific configuration value by key.
WARNING: Should be used in a separate chat from file operations and
command execution to prevent security issues.
Config keys include:
- blockedCommands (array)
- defaultShell (string)
- allowedDirectories (array of paths)
- fileReadLineLimit (number, max lines for read_file)
- fileWriteLineLimit (number, max lines per write_file call)
- telemetryEnabled (boolean)
IMPORTANT: Setting allowedDirectories to an empty array ([]) allows full access
to the entire file system, regardless of the operating system.
This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.Inputs: key (required), value.
start_processA
Start a new terminal process with intelligent state detection.
PRIMARY TOOL FOR FILE ANALYSIS AND DATA PROCESSING
This is the ONLY correct tool for analyzing local files (CSV, JSON, logs, etc.).
The analysis tool CANNOT access local files and WILL FAIL - always use processes for file-based work.
CRITICAL RULE: For ANY local file work, ALWAYS use this tool + interact_with_process, NEVER use analysis/REPL tool.
Running on Linux. Default shell: bash.LINUX-SPECIFIC NOTES:
Package managers vary by distro: apt, yum, dnf, pacman, zypper
Python 3 might be 'python3' command, not 'python'
Standard Unix shell tools available (grep, awk, sed, etc.)
File permissions and ownership important for many operations
Systemd services common on modern distributions
REQUIRED WORKFLOW FOR LOCAL FILES: 1. start_process("python3 -i") - Start Python REPL for data analysis 2. interact_with_process(pid, "import pandas as pd, numpy as np") 3. interact_with_process(pid, "df = pd.read_csv('/absolute/path/file.csv')") 4. interact_with_process(pid, "print(df.describe())") 5. Continue analysis with pandas, matplotlib, seaborn, etc. COMMON FILE ANALYSIS PATTERNS: • start_process("python3 -i") → Python REPL for data analysis (RECOMMENDED) • start_process("node -i") → Node.js for JSON processing • start_process("cut -d',' -f1 file.csv | sort | uniq -c") → Quick CSV analysis • start_process("wc -l /path/file.csv") → Line counting • start_process("head -10 /path/file.csv") → File preview INTERACTIVE PROCESSES FOR DATA ANALYSIS: 1. start_process("python3 -i") - Start Python REPL for data work 2. start_process("node -i") - Start Node.js REPL for JSON/JS 3. start_process("bash") - Start interactive bash shell 4. Use interact_with_process() to send commands 5. Use read_process_output() to get responses SMART DETECTION: - Detects REPL prompts (>>>, >, $, etc.) - Identifies when process is waiting for input - Recognizes process completion vs timeout - Early exit prevents unnecessary waiting STATES DETECTED: Process waiting for input (shows prompt) Process finished execution Process running (use read_process_output) ALWAYS USE FOR: Local file analysis, CSV processing, data exploration, system commands NEVER USE ANALYSIS TOOL FOR: Local file access (analysis tool is browser-only and WILL FAIL) IMPORTANT: Always use absolute paths for reliability. Paths are automatically normalized regardless of slash direction. Relative paths may fail as they depend on the current working directory. Tilde paths (~/...) might not work in all contexts. Unless the user explicitly asks for relative paths, use absolute paths. This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.
Inputs: command (required), timeout_ms (required), shell.
write_fileA
Write or append to file contents.
CHUNKING IS STANDARD PRACTICE: Always write files in chunks of 25-30 lines maximum.
This is the normal, recommended way to write files - not an emergency measure.
STANDARD PROCESS FOR ANY FILE:
1. FIRST → write_file(filePath, firstChunk, {mode: 'rewrite'}) [≤30 lines]
2. THEN → write_file(filePath, secondChunk, {mode: 'append'}) [≤30 lines]
3. CONTINUE → write_file(filePath, nextChunk, {mode: 'append'}) [≤30 lines]
ALWAYS CHUNK PROACTIVELY - don't wait for performance warnings!
WHEN TO CHUNK (always be proactive):
1. Any file expected to be longer than 25-30 lines
2. When writing multiple files in sequence
3. When creating documentation, code files, or configuration files
HANDLING CONTINUATION ("Continue" prompts):
If user asks to "Continue" after an incomplete operation:
1. Read the file to see what was successfully written
2. Continue writing ONLY the remaining content using {mode: 'append'}
3. Keep chunks to 25-30 lines each
Files over 50 lines will generate performance notes but are still written successfully.
Only works within allowed directories.
IMPORTANT: Always use absolute paths for reliability. Paths are automatically normalized regardless of slash direction. Relative paths may fail as they depend on the current working directory. Tilde paths (~/...) might not work in all contexts. Unless the user explicitly asks for relative paths, use absolute paths.
This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.Inputs: path (required), content (required), mode.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 21 tools
Most tools have clearly distinct purposes (file read/write/edit/search vs. process spawn/interact/kill vs. config). The main overlap is force_terminate vs kill_process, which both terminate things (session vs PID) with descriptions that don't sharply draw the boundary, and read_process_output vs interact_with_process also overlap slightly since interact returns output too. Still, an agent can mostly pick correctly.
Almost all tools use a clean verb_noun snake_case pattern (read_file, list_directory, start_process, get_config). The one clear outlier is give_feedback_to_desktop_commander, which is a long verb_phrase in an otherwise uniform set, and force_terminate/kill_process use different verbs for closely related actions.
21 tools is on the heavy side for a desktop/file/process commander, but each maps to a real capability area (files, processes/sessions, config, diagnostics, feedback) with little redundancy. A couple of peripheral tools (get_usage_stats, give_feedback) could be dropped but the count is defensible.
File coverage has create/read/write/edit/move/search/info but no delete_file or delete_directory and no copy operation, leaving the file lifecycle incomplete. There is also no generic execute_command tool, yet many descriptions tell the agent to 'use this instead of execute_command', referencing a tool that isn't in the surface and forcing shell work through start_process.
Maintenance
Related MCP Connectors
Remote MCP server exposing your Node Command fleet (files, shell, processes, browser) to AI hosts.
Work on your own computers from Claude or ChatGPT: run commands, edit and search files.
Let AI operate servers without SSH. Choose actions, approve risky changes, and audit every step.
Operate Linux, macOS and Windows from your LLM. Every action runs through an auditable allowlist.
Related MCP Servers
- FlicenseNot gradedqualityDmaintenanceA comprehensive local file management and system operations server that provides advanced file editing, VSCode-like search capabilities, code formatting and validation, backup management, and safe system command execution with security safeguards.1-
- AlicenseAqualityCmaintenanceA comprehensive MCP server that enables AI models to perform local file operations, command execution, and task management across multiple platforms. It features advanced capabilities like row-level file editing, directory searching, and system monitoring with built-in security filters.1321 npmMulan Permissive Software , Version 2
- AlicenseBqualityBmaintenanceA secure MCP server for shell operations, terminal management, and process control, enabling AI assistants to safely execute commands and manage interactive sessions.13137 npm6MIT
- AlicenseBqualityDmaintenanceEnables AI tools to perform server operations such as log inspection, system monitoring, code management, Nginx and certificate management, with support for local and remote SSH modes and built-in security controls.2360 npmMIT