Skip to main content
Glama

Remote Command MCP Server

Remote Command MCP Server

A Model Context Protocol (MCP) server that enables remote command execution across different operating systems. This server provides a unified interface to execute shell commands, automatically handling platform-specific differences between Windows and Unix-like systems.

Features

  • Cross-platform command execution
  • Automatic command normalization between Windows and Unix
  • Built-in error handling and output streaming
  • Working directory specification support
  • Platform-specific shell selection

Installation

  1. Clone the repository:
git clone https://github.com/deepsuthar496/Remote-Command-MCP cd remote-command-server
  1. Install dependencies:
npm install
  1. Build the server:
npm run build
  1. Configure the MCP server in your settings file:

For VSCode Cline Extension (cline_mcp_settings.json):

{ "mcpServers": { "remote-command": { "command": "node", "args": ["path/to/remote-command-server/build/index.js"], "disabled": false, "autoApprove": [] } } }

Usage

The server provides a single tool called execute_remote_command that can execute ANY valid shell command on the host machine. This includes:

  • System commands
  • Package manager commands (apt, yum, chocolatey, etc.)
  • Development tools (git, npm, python, etc.)
  • File operations
  • Network commands
  • Service management
  • And any other CLI commands available on the system

Tool: execute_remote_command

Parameters:

  • command (required): Any valid shell command that can be executed on the host OS
  • cwd (optional): Working directory for command execution

Examples

  1. System Information:
<use_mcp_tool> <server_name>remote-command</server_name> <tool_name>execute_remote_command</tool_name> <arguments> { "command": "systeminfo" // Windows // or "uname -a" // Linux } </arguments> </use_mcp_tool>
  1. Package Management:
<use_mcp_tool> <server_name>remote-command</server_name> <tool_name>execute_remote_command</tool_name> <arguments> { "command": "npm list -g --depth=0" // List global NPM packages } </arguments> </use_mcp_tool>
  1. Network Operations:
<use_mcp_tool> <server_name>remote-command</server_name> <tool_name>execute_remote_command</tool_name> <arguments> { "command": "netstat -an" // Show all network connections } </arguments> </use_mcp_tool>
  1. Git Operations:
<use_mcp_tool> <server_name>remote-command</server_name> <tool_name>execute_remote_command</tool_name> <arguments> { "command": "git status", "cwd": "/path/to/repo" } </arguments> </use_mcp_tool>
  1. File Operations:
<use_mcp_tool> <server_name>remote-command</server_name> <tool_name>execute_remote_command</tool_name> <arguments> { "command": "ls -la", // List files with details "cwd": "/path/to/directory" } </arguments> </use_mcp_tool>
  1. Process Management:
<use_mcp_tool> <server_name>remote-command</server_name> <tool_name>execute_remote_command</tool_name> <arguments> { "command": "ps aux" // List all running processes (Unix) // or "tasklist" // Windows equivalent } </arguments> </use_mcp_tool>
  1. Service Control:
<use_mcp_tool> <server_name>remote-command</server_name> <tool_name>execute_remote_command</tool_name> <arguments> { "command": "systemctl status nginx" // Check service status (Linux) // or "sc query nginx" // Windows equivalent } </arguments> </use_mcp_tool>

Security Considerations

Since this server can execute any system command, please consider the following security practices:

  1. Access Control: Limit access to the MCP server to trusted users only
  2. Command Validation: Validate commands before execution in your application logic
  3. Working Directory: Use the cwd parameter to restrict command execution to specific directories
  4. Environment: Be cautious with commands that modify system settings or sensitive files
  5. Permissions: Run the MCP server with appropriate user permissions

Cross-Platform Command Handling

The server automatically handles platform-specific differences:

  1. Command Translation:
    • lsdir (automatically converted based on platform)
    • Proper pipe operator formatting for each platform
  2. Shell Selection:
    • Windows: Uses cmd.exe
    • Unix/Linux: Uses /bin/sh

Error Handling

The server provides detailed error messages and includes both stdout and stderr in the response. If a command fails, you'll receive an error message with details about what went wrong.

Example error response:

{ "content": [ { "type": "text", "text": "Command execution error: Command failed with exit code 1" } ], "isError": true }

Development

Project Structure

remote-command-server/ ├── src/ │ └── index.ts # Main server implementation ├── package.json ├── tsconfig.json └── README.md

Building

npm run build

This will compile the TypeScript code and create the executable in the build directory.

Contributing

  1. Fork the repository
  2. Create your feature branch (git checkout -b feature/amazing-feature)
  3. Commit your changes (git commit -m 'Add some amazing feature')
  4. Push to the branch (git push origin feature/amazing-feature)
  5. Open a Pull Request

License

This project is licensed under the MIT License - see the LICENSE file for details.

Install Server
A
security – no known vulnerabilities
A
license - permissive license
A
quality - confirmed to work

hybrid server

The server is able to function both locally and remotely, depending on the configuration or use case.

A Model Context Protocol server that enables remote execution of shell commands across different operating systems, automatically handling platform-specific differences between Windows and Unix-like systems.

  1. Features
    1. Installation
      1. Usage
        1. Tool: execute_remote_command
        2. Examples
        3. Security Considerations
        4. Cross-Platform Command Handling
        5. Error Handling
      2. Development
        1. Project Structure
        2. Building
      3. Contributing
        1. License

          Related MCP Servers

          • A
            security
            A
            license
            A
            quality
            A Model Context Protocol server that provides programmatic access to the Windows terminal, enabling AI models to interact with the Windows command line through standardized tools for writing commands, reading output, and sending control signals.
            Last updated -
            3
            JavaScript
            MIT License
          • -
            security
            F
            license
            -
            quality
            A Model Context Protocol server that allows LLMs to execute shell commands and receive their output in a controlled manner.
            Last updated -
            3
            Python
          • -
            security
            A
            license
            -
            quality
            A Model Context Protocol server that enables seamless execution of commands, Python code, web content fetching, and reusable task management with secure credentials handling.
            Last updated -
            2
            Python
            MIT License
            • Apple
          • A
            security
            F
            license
            A
            quality
            A Model Context Protocol server implementation that enables secure remote command execution via SSH, with features for managing and using SSH credentials.
            Last updated -
            5
            13
            8
            JavaScript

          View all related MCP servers

          MCP directory API

          We provide all the information about MCP servers via our MCP API.

          curl -X GET 'https://glama.ai/api/mcp/v1/servers/deepsuthar496/Remote-Command-MCP'

          If you have feedback or need assistance with the MCP directory API, please join our Discord server