A
licenseNot graded
qualityD
maintenanceAn enhanced MCP server that grants AI assistants the ability to execute terminal commands on a user's system with improved security controls, designed for use in controlled environments.
2
MIT
Super Windows CLI MCP Server
by delorenj
The Super Windows CLI MCP Server allows unrestricted command execution on Windows with SYSTEM privileges:
Execute commands: Run commands in PowerShell, CMD, or Git Bash with optional working directory
Unrestricted access: No command restrictions, full file system access, and SYSTEM-level service installation
SSH operations: Execute commands on remote hosts and disconnect from SSH servers
Command history: View previously executed commands with details including output, timestamp, and exit code
Network security: Control access through localhost binding, IP range configuration, and VPN integration
System control: Manage processes without resource limitations with auto-recovery capabilities
Click on "Install 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., "@Super Windows CLI MCP Servershow me all running processes with memory usage"
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.
Super Windows CLI MCP Server
An enhanced fork of the Windows CLI MCP Server with unrestricted system access capabilities.
Enhancements
Full system access through SYSTEM service installation
Unrestricted command execution
Network-level access controls
Unlimited process capabilities
Auto-recovery and fault tolerance
PowerShell telemetry disabled
Related MCP server: Super Windows CLI MCP Server
Security Notice
This version removes application-level restrictions in favor of network-level security. It is designed for use in trusted environments where full system access is required.
Features
Complete access to Windows shell environments (PowerShell, CMD, Git Bash)
No command or argument restrictions
Full file system access
SYSTEM-level service installation
Automatic service recovery
Network binding controls
Process reuse for performance
Extended timeouts for long-running operations
Installation
Build the project:
npm install
npm run buildCopy the built files to your Windows machine
Run the installation script as administrator:
.\install-service.ps1Configuration
The server is configured for maximum capability with these key features:
No command restrictions
Full filesystem access
Disabled injection protection
Unlimited process resources
Network-level access control
SYSTEM-level privileges
See config.json for the complete configuration.
Service Management
Installation
.\install-service.ps1Removal
.\uninstall-service.ps1Network Security
While application-level restrictions are removed, the following network-level protections are in place:
Localhost binding by default
Configurable allowed IP ranges
Local network restriction
Optional VPN integration
License
This project is licensed under the MIT License - see the LICENSE file for details.
Acknowledgments
Based on the original win-cli-mcp-server by SimonB97.
Available Tools
4 toolsexecute_commandB
Execute a command in the specified shell (powershell, cmd, or gitbash)
Example usage (PowerShell):
{
"shell": "powershell",
"command": "Get-Process | Select-Object -First 5",
"workingDir": "C:\Users\username"
}Example usage (CMD):
{
"shell": "cmd",
"command": "dir /b",
"workingDir": "C:\Projects"
}Example usage (Git Bash):
{
"shell": "gitbash",
"command": "ls -la",
"workingDir": "/c/Users/username"
}ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| shell | Yes | Shell to use for command execution | |
| command | Yes | Command to execute | |
| workingDir | No | Working directory for command execution (optional) |
TDQS
B3.4/5.0
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It mentions the tool executes commands but lacks critical behavioral details: it doesn't specify whether this is a read-only or destructive operation, what permissions are required, how errors are handled, or what the output format looks like. The examples show input but not expected results, leaving the agent uncertain about the tool's behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with a clear purpose statement, but it includes three lengthy code examples that could be condensed. While examples are helpful, they dominate the text and could be summarized more efficiently. The structure is logical but not optimally concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of a command execution tool with no annotations and no output schema, the description is incomplete. It lacks information on security implications, error handling, output format, and how it differs from sibling tools like ssh_execute. The examples provide input syntax but leave the agent guessing about behavioral outcomes and integration context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description adds value by providing concrete examples for each shell type, illustrating how parameters interact (e.g., shell-specific command syntax and working directory paths). This enhances understanding beyond the schema's basic descriptions, though it doesn't fully explain all edge cases or optional behaviors.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Execute a command') and resource ('in the specified shell'), distinguishing it from siblings like get_command_history (which retrieves history) and ssh_execute (which executes over SSH). The three shell options are explicitly listed, making the purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage by providing examples for each shell type, but it does not explicitly state when to use this tool versus alternatives like ssh_execute or get_command_history. There's no guidance on prerequisites, error handling, or specific contexts where this tool is preferred over siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_command_historyC
Get the history of executed commands
Example usage:
{
"limit": 5
}Example response:
[
{
"command": "Get-Process",
"output": "...",
"timestamp": "2024-03-20T10:30:00Z",
"exitCode": 0
}
]ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Maximum number of history entries to return (default: 10, max: 1000) |
TDQS
C2.9/5.0
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It states it retrieves history but doesn't disclose behavioral traits like whether it's read-only (implied by 'Get'), what data format or pagination is used, or any rate limits. The example response adds some context but lacks comprehensive behavioral details.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded with the purpose statement. The example usage and response are relevant but could be more concise; however, they earn their place by providing practical context without unnecessary verbosity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (1 parameter, no output schema, no annotations), the description is minimally adequate. It covers the basic purpose and includes examples, but lacks details on usage guidelines and behavioral transparency, which are gaps for a tool with no annotations.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, with the 'limit' parameter fully documented. The description doesn't add any parameter semantics beyond what the schema provides, but the example usage illustrates how to use 'limit'. Baseline 3 is appropriate since the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with 'Get the history of executed commands', which is a specific verb+resource combination. However, it doesn't explicitly differentiate from sibling tools like 'execute_command' or 'ssh_execute', which are for executing commands rather than retrieving history.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools or provide context about prerequisites, such as whether commands need to have been executed first. The example usage is helpful but doesn't address usage scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
ssh_disconnectA
Disconnect from an SSH server
Example usage:
{
"connectionId": "raspberry-pi"
}Use this to cleanly close SSH connections when they're no longer needed.
ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| connectionId | Yes | ID of the SSH connection to disconnect |
TDQS
A3.9/5.0
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states this is for 'cleanly close SSH connections' which implies a safe, controlled termination. However, it doesn't mention potential side effects (e.g., whether active commands are interrupted), authentication requirements, or error conditions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is perfectly structured and concise: a clear purpose statement, a helpful example, and a usage guideline - all in three sentences with zero wasted words. The example is appropriately formatted and directly relevant.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a single-parameter tool with no output schema and no annotations, the description provides adequate context about what the tool does and when to use it. The main gap is the lack of information about what happens after disconnection or potential error scenarios, but given the tool's simplicity, this is reasonably complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 100% description coverage, so the parameter is well-documented in the structured data. The description doesn't add significant semantic information beyond what's in the schema, but the example usage provides helpful context for how the parameter should be used ('raspberry-pi' as an example value).
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with a specific verb ('Disconnect') and resource ('SSH server'), making it immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'ssh_execute' or mention that this is specifically for closing connections rather than executing commands.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context about when to use the tool ('when they're no longer needed') and includes an example usage. However, it doesn't explicitly mention alternatives or when NOT to use it (e.g., vs keeping connections open for reuse).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
ssh_executeB
Execute a command on a remote host via SSH
Example usage:
{
"connectionId": "raspberry-pi",
"command": "uname -a"
}Configuration required in config.json:
{
"ssh": {
"enabled": true,
"connections": {
"raspberry-pi": {
"host": "raspberrypi.local",
"port": 22,
"username": "pi",
"password": "raspberry"
}
}
}
}ParametersJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| connectionId | Yes | ID of the SSH connection to use | |
| command | Yes | Command to execute |
TDQS
B3.3/5.0
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It describes the action and configuration but lacks critical details: it doesn't mention authentication requirements (implied by config but not stated), potential security risks, error handling, or output format. For a tool that executes remote commands with no annotation coverage, this is a significant gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized and front-loaded with the core purpose in the first sentence. The example and configuration details are relevant but could be more concise; the configuration block is lengthy and might be better summarized. Overall, it's efficient with minimal waste.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of SSH command execution, no annotations, and no output schema, the description is incomplete. It covers basic usage and configuration but omits essential context: authentication details, error scenarios, security implications, and what the tool returns (e.g., stdout, stderr, exit code). This leaves gaps for an AI agent to use the tool safely and effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with clear descriptions for both parameters ('connectionId' and 'command'). The description adds minimal value beyond the schema—it provides an example usage that illustrates parameter semantics but doesn't explain enum values for 'connectionId' or additional constraints. Baseline 3 is appropriate as the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Execute a command') and resource ('on a remote host via SSH'), distinguishing it from sibling tools like 'execute_command' (likely local), 'get_command_history' (query), and 'ssh_disconnect' (connection management). The verb+resource combination is precise and unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context through the example and configuration details, suggesting it's for remote SSH execution. However, it doesn't explicitly state when to use this tool versus alternatives like 'execute_command' (presumably for local commands) or provide clear exclusions. The guidance is helpful but not comprehensive.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
4 tool updates
- First observed
execute_command - First observed
get_command_history - First observed
ssh_disconnect - First observed
ssh_execute
TDQS
B3.1/5.0
Disambiguation3/5
The tools have some overlap in purpose that could cause confusion. execute_command and ssh_execute both execute commands but in different contexts (local vs remote), which might lead to misselection if the agent doesn't carefully distinguish between local and remote execution. However, get_command_history and ssh_disconnect are clearly distinct from the execution tools.
Naming Consistency4/5
The naming follows a mostly consistent verb_noun pattern with clear actions like execute, get, and disconnect. All tools use snake_case consistently. The minor deviation is that ssh_disconnect uses 'disconnect' while others use more specific verbs, but overall it's readable and predictable.
Tool Count3/5
With only 4 tools, the count feels borderline thin for a 'Super Windows CLI MCP Server' that implies broader command-line capabilities. It covers basic execution and SSH operations but lacks tools for file management, process control, or other common CLI tasks, making the scope seem underdeveloped.
Completeness2/5
There are significant gaps in the tool surface for a Windows CLI server. It includes command execution and SSH operations but misses core functionalities like file operations (e.g., copy, move, delete), process management (e.g., start, stop), system information retrieval, or network utilities. The SSH tools are incomplete without a corresponding ssh_connect tool to establish connections.
Maintenance
ActivityInactive
ResponsivenessSyncing
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
An MCP server for deep research or task groups
Personal assistant MCP server with search, execute, packages, jobs, secrets, and integrations.
Security research canary remote MCP server for owned-account testing.
A paid remote MCP for ClawManager, built to return verdicts, receipts, usage logs, and audit-ready J
Related MCP Servers
- AlicenseBqualityDmaintenanceA command-line interface server that provides unrestricted system access to Windows environments with SYSTEM-level privileges, allowing complete control over files, processes, and configuration settings.41,215MIT
- AlicenseAqualityDmaintenanceAn MCP server that grants AI agents unrestricted file system, Python, and PowerShell access on Windows for real, unfiltered automation.141MIT
- AlicenseNot gradedqualityCmaintenanceEnables remote filesystem and CLI access to a Windows machine over LAN through MCP, with file read/write and command execution capabilities.MIT
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
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/delorenj/super-win-cli-mcp-server'
If you have feedback or need assistance with the MCP directory API, please join our Discord server