Rob Desktop Commander
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., "@Rob Desktop Commander search for TODO comments in src and list the files"
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.
Rob Desktop Commander
Rob Desktop Commander is a private, self-hosted Model Context Protocol (MCP) server for controlling a workstation from an MCP-capable AI client.
It is designed to replace the hosted Remote Desktop Commander relay for Rob's workflows: no provider account dependency, no telemetry service, no third-party relay quota, and a tool surface optimized for repeated software-project work.
Current version
v0.3.2
Core goals:
efficient single-call operations instead of unnecessary MCP round-trips;
fair multi-project concurrency;
bounded queues and output buffers;
safe concurrent file editing;
efficient streaming search;
detailed optional JSONL diagnostics;
no inbound public MCP listener;
Windows-first behavior while remaining cross-platform.
Related MCP server: local-mcp
Architecture
ChatGPT / MCP client
|
| MCP
v
OpenAI Secure MCP Tunnel (optional for ChatGPT)
|
| outbound HTTPS from the PC
v
tunnel-client
|
| stdio
v
Rob Desktop Commander
|
+-- workspace-aware scheduler
+-- filesystem
+-- streaming ripgrep
+-- PowerShell / shell processes
+-- persistent process sessions
+-- metrics + optional debug JSONL logsRob Desktop Commander itself speaks MCP over stdio. It does not open an inbound network port.
Tool surface
The v0.3 surface deliberately stays compact even after adding batch operations.
Tool | Purpose |
| Runtime, concurrency, logging and optional performance/session diagnostics |
| Runtime logging status / enable / disable / flush / log-level control |
| Efficient text range, tail, or base64-prefix read; hashing opt-in |
| Batch-read multiple UTF-8 file prefixes |
| Atomic write/append with optional SHA-256 precondition |
| Concurrent multi-file creation/update in one MCP call |
| Exact validated patch of one file or multiple files in parallel |
| Bounded tree listing with common generated directories excluded by default |
| stat/mkdir/move/copy/delete |
| Streaming ripgrep content, filename, or files-with-matches search |
| One-call project root + Git status + manifests + compact top-level inspection |
| One shell command; direct result or automatic persistent-session detach |
| Multiple commands in parallel or sequentially in one MCP call |
| Persistent process start/read/input/kill/list via a single action-based tool |
The older five-tool process surface was intentionally collapsed into process so the model has fewer tools to choose between.
Efficiency changes in v0.3
Fewer MCP round-trips
exec still returns short-command output in the same MCP call. Longer commands auto-detach.
New high-value batch operations reduce repeated calls further:
exec_batch: up to 12 independent commands;fs_write_many: up to 32 independent files;fs_patch: up to 32 independent files when usingfiles[];workspace_inspect: replaces several common tree / Git / manifest inspection calls.
File hashing is now opt-in
Earlier versions calculated SHA-256 around writes even when the caller did not need it.
v0.3 only performs a full existing-file hash when:
expectedSha256is supplied, orthe caller explicitly asks for a returned hash.
For a normal overwrite, the after-hash can be computed directly from the content already in memory instead of rereading the file.
Streaming search
search no longer needs to buffer an entire repository result set before returning the first N results.
It streams ripgrep output and terminates collection after either:
maxResultsis reached, orthe configured output-character budget is reached.
Modes:
content: matching lines;name: matching paths;files: files containing matching content.
Efficient text reads
fs_read supports:
fast direct line-range reads for files up to 2 MiB, avoiding async
readlineoverhead;bounded-memory streaming fallback for larger files;
adaptive backward tail reads that start at 1 KiB and grow only when more history is needed;
binary/base64 prefixes;
optional SHA-256.
The fast range path does not cache file contents, so external edits are visible immediately. This is particularly useful for source files and large debug logs.
Efficient process output
Persistent process reads are event-driven.
A process { action: "read", waitMs: ... } call wakes as soon as:
new stdout/stderr arrives, or
the process exits,
instead of blindly sleeping for the whole wait interval.
The process output buffer is bounded. If an extremely noisy process exceeds the retained output budget, old events are dropped in batches and the response reports droppedBeforeSeq.
Multi-project concurrency
Workspace detection first searches upward for a Git root. If none exists it falls back to common project markers, including:
package.jsonpyproject.tomlCargo.tomlgo.modMaven / Gradle
Composer
Ruby
Elixir
Deno
The workspace resolver uses a bounded TTL/LRU-like cache.
Default scheduler limits:
child processes: 8 global / 3 per workspace;
ripgrep searches: 4 global / 2 per workspace;
filesystem I/O: 24 global / 8 per workspace.
The queue is fair round-robin by workspace, not a single FIFO. A project with a large backlog therefore cannot put every later project behind all of its queued work.
Auto-detached processes keep their process slot until they actually exit.
Writes/patches touching the same path are serialized; unrelated paths can run concurrently.
Queues are also bounded by default:
1000 queued operations globally
100 queued operations per workspace
This prevents an accidental burst from consuming unbounded memory.
In-memory metrics
rob_status reports per-tool metrics such as:
call count;
errors;
average / maximum / last duration;
average / maximum queue wait.
It also reports pool utilization and rejection/timeout counters.
By default rob_status does not include the full session list to keep its response compact. Use includeSessions: true when needed.
Detailed debug logging
File logging is disabled by default.
Enable it for the first days of testing with:
$env:ROB_DC_LOG_ENABLED = "1"
$env:ROB_DC_LOG_LEVEL = "debug"or use the convenience launchers:
.\scripts\start-debug.ps1For the ChatGPT tunnel runtime:
.\scripts\run-openai-tunnel-debug.ps1Default log directory:
<repository>\.rob-dc\logsLogs are JSON Lines (.jsonl) and include events such as:
server startup;
tool start/end/error and duration;
queue wait;
process start/close/error/timeout/kill;
process exit code and duration.
Payload contents are not fully logged by default. Strings are represented by size plus a short redacted preview. Obvious API-token patterns and secret-like keys are redacted.
To include fuller payloads while debugging:
$env:ROB_DC_LOG_INCLUDE_PAYLOADS = "1"Use this only when necessary because file contents, commands or other sensitive data may then be present in the logs.
Logging can also be changed without restarting through rob_logging:
action=status
action=enable
action=disable
action=flush
action=set_level level=debug|info|warn|errorLog rotation defaults to 25 MB per file and 7 files.
Configuration
Variable | Default | Meaning |
| user home | Filesystem-tool roots; |
| PowerShell on Windows | Shell used for shell commands |
| 30000 | Default |
| 2500 | Time before |
| 15000 | Maximum wait for a saturated pool |
| 1000 | Maximum queued jobs per pool globally |
| 100 | Maximum queued jobs per project in a pool |
| 600000 | Completed persistent-session retention |
| 8 | Running child processes globally |
| 3 | Running child processes per project |
| 4 | Concurrent searches globally |
| 2 | Concurrent searches per project |
| 24 | Concurrent filesystem jobs globally |
| 8 | Concurrent filesystem jobs per project |
| 1000000 | Per-stream retained/output budget |
| 2000000 | Default binary/tail/patch size budget |
| 500 | Global search-result ceiling |
| 300000 | Workspace cache TTL |
| 10000 | Workspace cache entry ceiling |
| 0 | Enable JSONL file logging |
| debug | Minimum file-log level |
|
| Log directory |
| 0 | Include expanded payload data |
| 25 | Maximum size per log file |
| 7 | Rotated files retained |
| 250 | Buffered log flush interval |
| 5000 | Maximum in-memory log event queue |
| 0 | Disable the lightweight dangerous-command guard |
The launch scripts default UV_THREADPOOL_SIZE to 8 to give concurrent filesystem operations more room on Windows.
Install
git clone https://github.com/Krineon-lab/MCP-CLI.git
cd MCP-CLI
npm install
npm testNormal local run:
.\scripts\start-local.ps1Debug local run:
.\scripts\start-debug.ps1Connect to ChatGPT with Secure MCP Tunnel
Create a Secure MCP Tunnel in OpenAI Platform and obtain its
tunnel_...ID.Create a restricted Runtime API key with Tunnels Read + Use.
Run the one-time Windows setup:
.\scripts\configure-tunnel-autostart.ps1The setup:
asks for the tunnel ID and runtime key locally;
stores the runtime key encrypted with Windows DPAPI for the current user;
creates the
rob-desktoptunnel-client profile;runs
doctor;enables detailed Rob Desktop Commander logging;
enables the live activity console;
installs the Rob Desktop Commander Scheduled Task;
starts the tunnel immediately.
The live console shows compact, color-coded activity without full payloads: file reads/writes, searches, commands, process lifecycle, durations, queue waits, errors and tunnel health. Closing the console does not stop the tunnel.
Windows management command
RobDC.cmd provides one compact control surface for day-to-day use:
RobDC status
RobDC start
RobDC restart
RobDC stop
RobDC monitor
RobDC monitor-stop
RobDC logsRunning the repository RobDC.cmd without arguments opens an interactive menu. On Windows, it can optionally be copied to a directory on the user PATH (for example %USERPROFILE%\bin) and exposed through Desktop shortcuts for the control menu and live monitor.
The Scheduled Task runs at user logon (rather than before login) so the current-user DPAPI secret can be decrypted safely. It restarts automatically after failures and removes any stale orphaned rob-desktop tunnel-client instance before starting a new one.
The runtime script used by the task is:
.\scripts\run-tunnel-service.ps1Once the daemon is healthy, open ChatGPT connector settings, choose Connection: Tunnel, then select the tunnel or paste its tunnel ID. The daemon must remain running for connector discovery and every later MCP call.
Security model
This server is intentionally powerful.
ROB_DC_ALLOWED_DIRS restricts the dedicated filesystem tools. It is not an operating-system sandbox for arbitrary shell commands.
Commands launched through exec, exec_batch or process run with the permissions of the account that started the server.
For hard isolation, run Rob Desktop Commander under a dedicated low-privilege account, VM or container.
The dangerous-command matcher is a guardrail, not a security boundary.
Never expose the stdio server through an unauthenticated public proxy.
Testing
npm run check
npm test
npm run benchThe automated suite covers:
dangerous-command regressions;
fair concurrency;
same-path locking;
bounded queue rejection;
workspace detection/cache isolation;
streaming search limits;
efficient tail/range reads;
real concurrent MCP calls across two projects;
JSONL logging enable/flush/disable;
batch file patch/write;
batch command execution;
event-driven persistent-process reads;
normal MCP handshake/tool enumeration.
Local benchmark
On the development PC during the v0.3 second optimization pass:
Benchmark | Result |
workspace resolver, cold + 999 warm calls | 7.87 ms |
tail read ×100 | 32.23 ms |
line 40000 range read ×20 | 32.18 ms |
fair scheduler, 2000 jobs | 13.07 ms |
The v0.3.2 text-read optimization reduced the local tail benchmark from 81.9 ms to 32.23 ms and the line-40000 range benchmark from 263.1 ms to 32.18 ms on the development PC. The earlier workspace benchmark was ~61.5 ms before the exact-path cache.
These are local microbenchmarks, not universal performance guarantees.
License
MIT. See LICENSE.
Desktop Commander is a separate MIT-licensed project; see THIRD_PARTY_NOTICES.md.
Available Tools
14 toolsexecBDestructive
Run a shell command efficiently. If it finishes before detachAfterMs, stdout/stderr and exit code are returned in this same MCP call. If still running, it automatically becomes a persistent session and returns sessionId.
Inputs: command (required), cwd, shell, timeoutMs, +1 more.
fs_listBRead-onlyIdempotent
List a directory tree with bounded recursion and result count.
Inputs: path (required), depth, maxEntries.
fs_manageCDestructive
Perform filesystem management in one tool: stat, mkdir, move, copy or delete. destination is required for move/copy.
Inputs: path (required), operation (required), force, recursive, +1 more.
fs_patchADestructive
Apply one or more exact text replacements to a file in memory, validate expected match counts, then write once atomically.
Inputs: path (required), edits (required), expectedSha256.
fs_readARead-onlyIdempotent
Read one local file. Supports UTF-8 line slicing or base64 for binary files. Prefer fs_read_many when several files are needed.
Inputs: path (required), encoding, maxBytes, maxLines, +1 more.
fs_read_manyARead-onlyIdempotent
Read multiple UTF-8 files in one MCP call. Use this instead of repeated fs_read calls when gathering project context.
Inputs: paths (required), maxBytesEach.
fs_writeADestructive
Create, overwrite or append a UTF-8 file. Overwrites are atomic by default and can use expectedSha256 as an optimistic concurrency guard.
Inputs: path (required), content (required), mode, atomic, +2 more.
process_inputCDestructive
Send input to an interactive persistent process session.
Inputs: input (required), sessionId (required), newline.
process_killADestructiveIdempotent
Terminate a persistent process session, including its child process tree on Windows.
Inputs: sessionId (required).
process_listARead-onlyIdempotent
List active and recently completed persistent process sessions.
Inputs: no named parameters.
process_readARead-only
Read new output events from a persistent process session. Omit cursor for incremental reads; provide cursor for explicit replay position.
Inputs: sessionId (required), cursor, waitMs.
process_startADestructive
Start a long-running or interactive command immediately and return a sessionId without waiting.
Inputs: command (required), cwd, shell.
rob_statusBRead-onlyIdempotent
Show Rob Desktop Commander runtime, security scope and active process sessions.
Inputs: no named parameters.
searchBRead-onlyIdempotent
Fast local search powered by ripgrep. mode=content searches text with line/column output; mode=name searches file paths.
Inputs: path (required), query (required), glob, mode, +4 more.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 14 tools
Most tools target clearly distinct resources or actions: process_* covers session lifecycle, fs_* covers filesystem operations, and search/exec are specific utilities. The main overlap is between exec and process_start, since exec can implicitly become a session, but the descriptions differentiate quick commands from explicit long-running sessions.
Nearly all names use snake_case with a domain prefix (process_, fs_, rob_) followed by an action, which is predictable and readable. The bare names search and exec are minor deviations from that prefix pattern, but not enough to cause confusion.
At 14 tools, the set is well-scoped for a desktop commander covering process control, filesystem access, search, and shell execution. Each tool earns its place, and fs_manage consolidates multiple filesystem operations without bloating the count.
The server covers the full lifecycle for its apparent domain: process start/list/read/input/kill, filesystem read/write/patch/list/manage (stat, mkdir, move, copy, delete), local search, shell execution, and runtime status. No obvious CRUD or workflow gaps remain for the stated purpose.
Related MCP Connectors
Remote MCP server exposing your Node Command fleet (files, shell, processes, browser) to AI hosts.
Remote MCP server for supportsheep: run AI interviews and manage support content for your blog.
Remote MCP server for supportsheep: run AI interviews and manage support content for your blog.
Nifty's MCP server — exposes tasks, projects, messages, and files as tools for AI agents.
Related MCP Servers
- AlicenseBqualityDmaintenanceProduction-grade MCP server that gives AI agents safe access to your local dev environment: filesystem, databases, processes, and OpenAPI specs.1555 npm4MIT
- AlicenseNot gradedqualityDmaintenanceA lightweight, stdio-based MCP server enabling AI assistants to perform local file system operations like reading, writing, searching, and executing commands.5,198 npmMIT
- AlicenseAqualityDmaintenanceA lightweight MCP server that enables AI assistants to execute local development tools and retrieve system status with low latency over stdio or HTTP.13MIT
- AlicenseNot gradedqualityDmaintenanceEnables remote MCP clients like ChatGPT to run shell commands and manage files on your local machine via a Cloudflare tunnel, exposing tools for file operations, search, and task management.7MIT