# Desktop Commander Installation Methods: Comparing 6 Setup Approaches and Update Mechanisms

> Explore six Desktop Commander installation methods comparing Node.js needs, auto-updates, and isolation. Learn which method suits your setup and update strategy.

- Repository: [Eduard Ruzga/DesktopCommanderMCP](https://github.com/wonderwhy-er/DesktopCommanderMCP)
- Tags: comparison
- Published: 2026-08-01

---

**The six Desktop Commander installation methods differ primarily in Node.js requirements, auto-update capabilities, and isolation levels, with only the local checkout requiring manual updates while Docker provides sandboxing without Node.js dependencies.**

DesktopCommanderMCP can be integrated with Claude Desktop through six distinct installation paths defined in the repository's [`README.md`](https://github.com/wonderwhy-er/DesktopCommanderMCP/blob/main/README.md). Each path varies in dependency requirements, update automation, and system isolation according to the project's installation scripts and configuration files. Understanding these differences ensures you select the optimal deployment strategy for your development environment.

## The Six Desktop Commander Installation Methods

### Method 1: NPX Installer

The **npx installer** executes the package's `setup` script via npx, which writes the MCP server entry into Claude's configuration and starts the server locally. This method requires **Node.js version 18 or higher** to be installed on the host system.

This approach automatically fetches the latest package version each time Claude Desktop restarts. To uninstall, run the remove command provided by the package.

```bash

# Install via npx (auto-updates, requires Node.js)

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

# Debug installation with inspector

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

# Remove installation

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

```

### Method 2: Bash Script Installer

The **Bash script installer** uses [`install.sh`](https://github.com/wonderwhy-er/DesktopCommanderMCP/blob/main/install.sh) to check for Node.js and automatically install Node version 22 if missing before running the npx setup routine. This method handles dependency management automatically through the shell script located at the repository root.

[`install.sh`](https://github.com/wonderwhy-er/DesktopCommanderMCP/blob/main/install.sh) pulls the latest npm package on each execution. Restarting Claude triggers the newest version automatically without manual intervention.

```bash

# Install via Bash script (auto-updates, installs Node.js if needed)

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

# Re-run the same command to update

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

```

### Method 3: Smithery Marketplace

**Smithery marketplace** installation uses the Smithery web UI to write the same MCP JSON entry as the npx installer. Users add the server through Smithery's interface, which sends the npm command to Claude Desktop.

Node.js must be present on the system since Smithery delegates to the npx command. Smithery re-installs the latest package whenever Claude restarts, providing automatic updates.

### Method 4: Manual Configuration

**Manual config edit** involves directly modifying [`claude_desktop_config.json`](https://github.com/wonderwhy-er/DesktopCommanderMCP/blob/main/claude_desktop_config.json) to point the `desktop-commander` server at `npx @wonderwhy-er/desktop-commander@latest`. This method provides full control over the configuration file but requires manual JSON editing.

Because the configuration references the npm package's `latest` tag, Claude fetches the newest version on each startup. Updates require editing the JSON with new package versions or simply restarting Claude.

```json
// Add to claude_desktop_config.json (auto-updates, requires Node.js)
{
  "mcpServers": {
    "desktop-commander": {
      "command": "npx",
      "args": [
        "-y",
        "@wonderwhy-er/desktop-commander@latest"
      ]
    }
  }
}

```

### Method 5: Local Checkout

**Local checkout** clones the repository and builds the server locally using `npm run setup`, registering it in Claude's config. This method does not automatically track upstream releases and requires manual maintenance according to the source documentation.

The [`track-installation.js`](https://github.com/wonderwhy-er/DesktopCommanderMCP/blob/main/track-installation.js) file runs during `npm install` to detect which installation path was used for telemetry purposes. Users must manually pull updates from the repository and rebuild when new versions release.

```bash

# Clone and setup locally (manual updates, requires Node.js)

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

# Update when new version releases

git pull
npm run setup

```

### Method 6: Docker Installation

The **Docker installer** pulls the pre-built image `mcp/desktop-commander:latest` using [`install-docker.sh`](https://github.com/wonderwhy-er/DesktopCommanderMCP/blob/main/install-docker.sh) (or `install-docker.ps1` for Windows). This creates persistent Docker volumes and writes a Docker-based MCP entry into Claude's configuration.

No Node.js runtime is required on the host since the entire stack runs inside the container. The Docker image uses the `latest` tag, refreshing on each Claude restart or manual `docker pull`.

```bash

# Docker installation (auto-updates, no Node.js required)

bash <(curl -fsSL https://raw.githubusercontent.com/wonderwhy-er/DesktopCommanderMCP/refs/heads/main/install-docker.sh)

# Manual image update

docker pull mcp/desktop-commander:latest

# Reset Docker installation

bash <(curl -fsSL https://raw.githubusercontent.com/wonderwhy-er/DesktopCommanderMCP/refs/heads/main/install-docker.sh) --reset

```

## Node.js and Dependency Requirements

Methods 1 through 5 require a working **Node.js version 18 or higher** on the host system. The Bash script installer ([`install.sh`](https://github.com/wonderwhy-er/DesktopCommanderMCP/blob/main/install.sh)) automatically installs Node version 22 if absent, while other Node-dependent methods assume existing installation.

Method 6 removes the Node.js requirement entirely by running the server inside a Docker container. The [`package.json`](https://github.com/wonderwhy-er/DesktopCommanderMCP/blob/main/package.json) declares the CLI entry point that npx installers invoke, but this runs within the containerized environment when using Docker.

## Update Mechanisms and Version Control

**Automatic updates** occur in methods 1, 2, 3, 4, and 6. These configurations reference the npm package's `latest` tag or Docker's `latest` image, causing Claude Desktop to fetch the newest version on each restart.

**Manual updates** are required only for method 5 (local checkout). Users must execute `git pull` followed by `npm run setup` to synchronize with upstream releases. The [`track-installation.js`](https://github.com/wonderwhy-er/DesktopCommanderMCP/blob/main/track-installation.js) script detects which installation path was used during setup to help the telemetry system distinguish between methods.

## System Isolation and Security

Only the **Docker installation** provides full sandboxing with no host-level filesystem access, utilizing separate Docker volumes for persistence. All other methods run the server as a regular Node process directly on the host machine with standard filesystem permissions.

Methods 1-4 and 6 share a common auto-uninstaller via `npx @wonderwhy-er/desktop-commander@latest remove`. Method 5 requires manual removal of both the cloned directory and the MCP configuration entry in [`claude_desktop_config.json`](https://github.com/wonderwhy-er/DesktopCommanderMCP/blob/main/claude_desktop_config.json).

## Summary

- **Methods 1-4 and 6** provide automatic updates when Claude Desktop restarts, while **Method 5** requires explicit `git pull` and rebuild operations.
- **Node.js dependency** is mandatory for methods 1-5, with the Bash installer handling automatic Node installation; **Method 6** eliminates this requirement through containerization.
- **Docker installation** offers the only fully sandboxed environment, isolating the server from host filesystem access via container volumes.
- **Uninstallation** is standardized across methods 1-4 and 6 using the npx remove command, while method 5 requires manual cleanup of repository files and configuration entries.
- **Installation scripts** [`install.sh`](https://github.com/wonderwhy-er/DesktopCommanderMCP/blob/main/install.sh) and [`install-docker.sh`](https://github.com/wonderwhy-er/DesktopCommanderMCP/blob/main/install-docker.sh) (along with `install-docker.ps1` for Windows) automate setup for methods 2 and 6 respectively.

## Frequently Asked Questions

### Which Desktop Commander installation method is best for users without Node.js installed?

The **Bash script installer** (Method 2) or **Docker installation** (Method 6) are optimal for users lacking Node.js. The Bash script automatically installs Node version 22 if missing, while Docker requires no Node.js runtime on the host whatsoever. Both methods provide automatic updates and require minimal manual configuration.

### How do I update Desktop Commander when using the local checkout method?

You must manually pull changes from the repository and rebuild the server. Execute `git pull` to fetch the latest code from the GitHub repository, then run `npm run setup` to rebuild and re-register the server in Claude's configuration. Unlike other methods, this approach does not automatically synchronize with upstream releases when Claude restarts.

### Why does the Docker installation not require Node.js on the host system?

The Docker installation runs the entire Desktop Commander stack inside a containerized environment using the pre-built image `mcp/desktop-commander:latest`. The Node.js runtime and all dependencies are bundled within the Docker image itself, eliminating the need for host-level Node installation while providing isolated filesystem access through Docker volumes.

### Can I switch between installation methods after initial setup?

Yes, though you should first uninstall the existing method to prevent configuration conflicts. Run `npx @wonderwhy-er/desktop-commander@latest remove` to remove methods 1-4 and 6, or manually delete the cloned directory and config entries for method 5. Then proceed with the new installation method's specific setup commands, ensuring you restart Claude Desktop to load the new configuration from [`claude_desktop_config.json`](https://github.com/wonderwhy-er/DesktopCommanderMCP/blob/main/claude_desktop_config.json).