Skip to content
Back to search

mcp-server-commands

Model Context Protocol server to run commands (tool: `runProcess`)

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/g0t4--mcp-server-commands/badge.svg)](/listings/g0t4--mcp-server-commands)

HTML

<a href="/listings/g0t4--mcp-server-commands"><img src="/api/listings/g0t4--mcp-server-commands/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

To use with Claude Desktop, add the server config:

On MacOS: `~/Library/Application Support/Claude/claude_desktop_config.json` On Windows: `%APPDATA%/Claude/claude_desktop_config.json`

Groq Desktop (beta, macOS) uses `~/Library/Application Support/groq-desktop-app/settings.json`

Use the published npm package

Published to npm as [mcp-server-commands](https://www.npmjs.com/package/mcp-server-commands) using this [workflow](https://github.com/g0t4/mcp-server-commands/actions)

{
  "mcpServers": {
    "mcp-server-commands": {
      "command": "npx",
      "args": ["mcp-server-commands"]
    }
  }
}

Use a local build (repo checkout)

Make sure to run `npm run build`

{
  "mcpServers": {
    "mcp-server-commands": {
      // works b/c of shebang in index.js
      "command": "/path/to/mcp-server-commands/build/index.js"
    }
  }
}

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 154 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. ## `runProcess` tool
  2. The `runProcess` tool runs processes on the host machine. There are two mutually exclusive ways to invoke it:
  3. 1. **`command_line`** (string) — Executed via the system's default shell (just like typing into `bash`/`fish`/`pwsh`/etc). Shell features like pipes, redirects, and variable expansion all work.
  4. 2. **`argv`** (string array) — Direct executable invocation. `argv[0]` is the executable, the rest are arguments. No shell interpretation.
  5. You cannot pass both. The tool infers whether to use a shell from which parameter you provide.
  6. If you want your model to use specific shell(s) on a system, I would list them in your system prompt. Or, maybe in your tool instructions, though models tend to pay better attention to examples in a system prompt.
  7. Let me know if you encounter problems!
  8. ## Tools
  9. Tools are for LLMs to request. Claude Sonnet 3.5 intelligently uses `run_process`. And, initial testing shows promising results with [Groq Desktop with MCP](https://github.com/groq/groq-desktop-beta) and `llama4` models.
  10. Currently, just one command to rule them all!
  11. - `run_process` - run a command, i.e. `hostname` or `ls -al` or `echo "hello world"` etc
  12. - Returns `STDOUT` and `STDERR` as text
  13. - Optional `stdin` parameter means your LLM can
  14. - pass scripts over `STDIN` to commands like `fish`, `bash`, `zsh`, `python`
  15. - create files with `cat >> foo/bar.txt` from the text in `stdin`
  16. > [!WARNING]
  17. > Be careful what you ask this server to run!
  18. > In Claude Desktop app, use `Approve Once` (not `Allow for This Chat`) so you can review each command, use `Deny` if you don't trust the command.
  19. > Permissions are dictated by the user that runs the server.
  20. > DO NOT run with `sudo`.
  21. ## Video walkthrough
  22. <a href="https://youtu.be/0-VPu1Pc18w"><img src="https://img.youtube.com/vi/0-VPu1Pc18w/maxresdefault.jpg" width="480" alt="YouTube Thumbnail"></a>
  23. ## Prompts
  24. Prompts are for users to include in chat history, i.e. via `Zed`'s slash commands (in its AI Chat panel)
  25. - `run_process` - generate a prompt message with the command output
  26. * FYI this was mostly a learning exercise... I see this as a user requested tool call. That's a fancy way to say, it's a template for running a command and passing the outputs to the model!
  27. ## Development
  28. Install dependencies:
  29. ```bash
  30. npm install
  31. ```
  32. Build the server:
  33. ```bash
  34. npm run build
  35. ```
  36. For development with auto-rebuild:
  37. ```bash
  38. npm run watch
  39. ```
  40. ## Installation
  41. To use with Claude Desktop, add the server config:
  42. On MacOS: `~/Library/Application Support/Claude/claude_desktop_config.json`
  43. On Windows: `%APPDATA%/Claude/claude_desktop_config.json`
  44. Groq Desktop (beta, macOS) uses `~/Library/Application Support/groq-desktop-app/settings.json`
  45. ### Use the published npm package
  46. Published to npm as [mcp-server-commands](https://www.npmjs.com/package/mcp-server-commands) using this [workflow](https://github.com/g0t4/mcp-server-commands/actions)
  47. ```json
  48. {
  49. "mcpServers": {
  50. "mcp-server-commands": {
  51. "command": "npx",
  52. "args": ["mcp-server-commands"]
  53. }
  54. }
  55. }
  56. ```
  57. ### Use a local build (repo checkout)
  58. Make sure to run `npm run build`
  59. ```json
  60. {
  61. "mcpServers": {
  62. "mcp-server-commands": {
  63. // works b/c of shebang in index.js
  64. "command": "/path/to/mcp-server-commands/build/index.js"
  65. }
  66. }
  67. }
  68. ```
  69. ## Local Models
  70. - Most models are trained such that they don't think they can run commands for you.
  71. - Sometimes, they use tools w/o hesitation... other times, I have to coax them.
  72. - Use a system prompt or prompt template to instruct that they should follow user requests. Including to use `run_processs` without double checking.
  73. - Ollama is a great way to run a model locally (w/ Open-WebUI)
  74. ```sh
  75. # NOTE: make sure to review variants and sizes, so the model fits in your VRAM to perform well!
  76. # Probably the best so far is [OpenHands LM](https://www.all-hands.dev/blog/introducing-openhands-lm-32b----a-strong-open-coding-agent-model)
  77. ollama pull https://huggingface.co/lmstudio-community/openhands-lm-32b-v0.1-GGUF
  78. # https://ollama.com/library/devstral
  79. ollama pull devstral
  80. # Qwen2.5-Coder has tool use but you have to coax it
  81. ollama pull qwen2.5-coder
  82. ```
  83. ### HTTP / OpenAPI
  84. The server is implemented with the `STDIO` transport.
  85. For `HTTP`, use [`mcpo`](https://github.com/open-webui/mcpo) for an `OpenAPI` compatible web server interface.
  86. This works with [`Open-WebUI`](https://github.com/open-webui/open-webui)
  87. ```bash
  88. uvx mcpo --port 3010 --api-key "supersecret" -- npx mcp-server-commands
  89. # uvx runs mcpo => mcpo run npx => npx runs mcp-server-commands
  90. # then, mcpo bridges STDIO <=> HTTP
  91. ```
  92. > [!WARNING]
  93. > I briefly used `mcpo` with `open-webui`, make sure to vet it for security concerns.
  94. ### Logging
  95. Claude Desktop app writes logs to `~/Library/Logs/Claude/mcp-server-mcp-server-commands.log`
  96. By default, only important messages are logged (i.e. errors).
  97. If you want to see more messages, add `--verbose` to the `args` when configuring the server.
  98. By the way, logs are written to `STDERR` because that is what Claude Desktop routes to the log files.
  99. In the future, I expect well formatted log messages to be written over the `STDIO` transport to the MCP client (note: not Claude Desktop app).
  100. ### Debugging
  101. Since MCP servers communicate over stdio, debugging can be challenging. We recommend using the [MCP Inspector](https://github.com/modelcontextprotocol/inspector), which is available as a package script:
  102. ```bash
  103. npm run inspector
  104. ```
  105. The Inspector will provide a URL to access debugging tools in your browser.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.