DesktopCommanderMCP Installation Options: Comparing npx, Bash, Docker, and Manual Setup

DesktopCommanderMCP supports six installation methods that differ in dependency requirements, update automation, and environmental isolation, though all ultimately register the same MCP server functionality within Claude Desktop.

The wonderwhy-er/DesktopCommanderMCP repository provides flexible deployment pathways for integrating terminal control and file system access into Claude Desktop. Each DesktopCommanderMCP installation option targets specific environments—from ephemeral containers to local development checkouts—while executing identical server logic compiled from the src/ directory to dist/.

npx Installation (Quickest Setup)

The npx method provides the fastest entry point for users with existing Node.js installations. This approach executes a one-time command that fetches the latest npm package (@wonderwhy-er/desktop-commander), runs the embedded setup script, and registers the server in Claude's MCP configuration.

This method requires Node.js ≥14, though the underlying installer can automatically install Node if missing. Auto-updates occur seamlessly—each time Claude restarts, the npx call resolves the latest tag against the npm registry and downloads the newest version without manual intervention.

# Install or update

npx @wonderwhy-er/desktop-commander@latest setup

# Remove

npx @wonderwhy-er/desktop-commander@latest remove

Choose this option when you want zero file maintenance and already maintain a Node.js environment.

Bash Installer (Unix/Linux/macOS)

The Bash installer delivers a single-script solution that handles the entire setup process, including Node.js installation if absent. The script downloads install.sh from the repository root and pipes it to bash, automating global npm package installation and Claude configuration updates.

Unlike the standalone npx method, this approach requires only a Unix-like shell and internet connectivity. Re-running the same curl | bash command updates the installation to the latest release, making it ideal for users who prefer terminal-based automation without manually managing Node versions.

# Initial install or update

curl -fsSL https://raw.githubusercontent.com/wonderwhy-er/DesktopCommanderMCP/refs/heads/main/install.sh | bash

The install.sh script referenced in the repository root orchestrates this process, checking for dependencies before modifying the Claude Desktop configuration as documented in lines 165-176 of README.md.

Docker Deployment (Sandboxed Environment)

Docker provides complete OS-level isolation by running the pre-built image mcp/desktop-commander:latest in a containerized environment. This method requires Docker Desktop or Docker Engine on the host, but eliminates the need for Node.js installation entirely—the container encapsulates its own Node runtime along with the compiled server from dist/.

Updates proceed via standard Docker workflows; pulling the latest tag refreshes the image to the newest build. This approach sandboxed file system access unless explicitly granted through volume mounts, as documented in lines 232-255 of the repository's README.md and automated by the install-docker.sh script.

# Pull and run with desktop access

docker pull mcp/desktop-commander:latest
docker run -i --rm \
  -v "$HOME/Desktop:/mnt/desktop" \
  mcp/desktop-commander:latest
  

# Update

docker pull mcp/desktop-commander:latest

Select Docker when operating in locked-down environments, requiring reproducible deployments across machines, or when the host system cannot install Node.js.

Manual Configuration (Direct Control)

Advanced users can bypass automated installers by directly editing Claude's claude_desktop_config.json file. This manual method inserts a JSON block invoking npx with the -y flag, launching the server on demand without running a setup script.

The configuration entry points to the same command used by the npx method, ensuring automatic updates upon Claude restart. This approach suits users who version-control their Claude configuration or require scripted server registration across multiple machines.

{
  "mcpServers": {
    "desktop-commander": {
      "command": "npx",
      "args": ["-y", "@wonderwhy-er/desktop-commander@latest"]
    }
  }
}

Alternative Installation Methods

Smithery Marketplace

Smithery provides a GUI-based installation flow for users already utilizing the Smithery marketplace for MCP servers. After selecting Claude Desktop as the target client, Smithery writes the identical JSON configuration entry that npx generates, automatically pulling updates when Claude restarts. This method requires a Smithery account and Node.js runtime.

Local Checkout (Development)

For contributors or users requiring source modifications, cloning the repository and running npm run setup builds the server from TypeScript sources in src/ to dist/. This method requires Node.js, npm, and Git, but does not auto-update—maintenance requires explicit git pull && npm run setup operations.

git clone https://github.com/wonderwhy-er/DesktopCommanderMCP.git
cd DesktopCommanderMCP
npm run setup          # initial install

git pull && npm run setup   # manual update

Architectural Implications

Regardless of installation method, all paths converge on the same runtime behavior defined in src/ and compiled to dist/. However, critical differences exist in dependency management and isolation:

Runtime Environment

All non-Docker methods execute Node.js processes directly on the host using the compiled output from dist/. The Docker method encapsulates Node within the container image built via the repository's Dockerfile, eliminating host-side Node requirements.

Configuration Handling

Automated installers (npx, Bash, Smithery) modify the mcpServers section of Claude's configuration automatically. Manual and Docker methods require explicit JSON editing using templates shown in README.md lines 165-176 (standard) and lines 232-255 (Docker-specific).

Update Mechanisms

Methods utilizing the latest tag—npx, Bash, Docker, Smithery, and manual npx-based configs—resolve the newest version at each Claude startup by checking their respective registries. The local checkout method requires manual version control operations via Git.

Isolation Guarantees

Docker provides full process and filesystem isolation, restricting server access to explicitly mounted volumes defined in the run command. Other methods inherit the user's host permissions, allowing broad file system access as declared in plugin.json metadata.

Summary

• npx offers the fastest setup for Node.js users with automatic updates via npm registry resolution.
• Bash installer handles complete dependency installation (including Node.js) on Unix systems through the install.sh script.
• Docker delivers sandboxed execution without host Node.js requirements, using the mcp/desktop-commander:latest image and install-docker.sh for configuration.
• Manual configuration allows direct JSON editing for users managing their own Claude Desktop configs.
• Local checkout enables source-level modifications but requires manual Git-based updates.
• All methods ultimately execute identical server logic from the compiled dist/ directory, differing only in deployment mechanics and isolation levels.

Frequently Asked Questions

Which DesktopCommanderMCP installation option is best for beginners?

The npx method provides the simplest experience for users with Node.js already installed, requiring only a single command. If Node.js is not present, the Bash installer automates the entire setup process including runtime installation, making it ideal for Unix/Linux/macOS beginners who prefer terminal-based workflows.

Do I need Node.js installed for all installation methods?

No. While npx, Bash, manual, and local checkout methods ultimately require Node.js to execute the server, the Bash installer automatically installs Node if missing, and the Docker method bundles Node within the container image, requiring only Docker on the host system.

How do I update DesktopCommanderMCP after installation?

npx, Bash, Docker, and manual (npx-based) configurations auto-update when Claude Desktop restarts, as they resolve the latest tag against their respective registries. Smithery similarly auto-updates through its marketplace. Only the local checkout method requires manual intervention via git pull && npm run setup.

Can I run DesktopCommanderMCP without granting full host file access?

Yes. The Docker installation provides OS-level isolation, allowing you to explicitly define accessible directories through volume mounts (e.g., -v "$HOME/Desktop:/mnt desktop"). Other installation methods run directly on the host and inherit user permissions, providing broader file system access by default.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}