Windows 시스템에서 안전한 명령줄 상호작용을 위한 MCP 서버로 , SSH를 통해 PowerShell, CMD, Git Bash 셸 및 원격 시스템에 대한 제어된 액세스를 지원합니다. MCP 클라이언트(예: Claude Desktop )가 Open Interpreter 와 유사하게 시스템에서 작업을 수행할 수 있도록 지원합니다.
[!중요] 이 MCP 서버는 SSH를 통해 시스템의 명령줄 인터페이스와 원격 시스템에 직접 액세스할 수 있도록 합니다. 활성화하면 파일, 환경 변수, 명령 실행 기능 및 원격 서버 관리에 액세스할 수 있습니다.
허용된 경로 및 SSH 연결을 검토하고 제한합니다.
디렉토리 제한 활성화
명령 블록 구성
보안 영향을 고려하세요
자세한 내용은 구성을 참조하세요.
멀티 셸 지원 : PowerShell, 명령 프롬프트(CMD), Git Bash에서 명령 실행
SSH 지원 : SSH를 통해 원격 시스템에서 명령 실행
리소스 노출 : SSH 연결, 현재 디렉토리 및 구성을 MCP 리소스로 보기
보안 제어 :
명령어 및 SSH 명령어 차단(전체 경로, 대소문자 변형)
작업 디렉토리 검증
최대 명령 길이 제한
명령 로깅 및 기록 추적
스마트한 인수 검증
구성 가능 :
사용자 정의 보안 규칙
셸별 설정
SSH 연결 프로필
경로 제한
차단된 명령 목록
MCP 클라이언트에 서버가 제공하는 도구와 리소스에 대한 자세한 내용은 API 섹션을 참조하세요.
참고 : 서버는 구성된 디렉토리 내에서 허용된 명령을 사용하고 구성된 SSH 연결을 통해서만 작업을 허용합니다.
Related MCP server: Super Shell MCP Server
claude_desktop_config.json 에 다음을 추가하세요:
지엑스피1
특정 구성 파일과 함께 사용하려면 --config 플래그를 추가하세요.
{
"mcpServers": {
"windows-cli": {
"command": "npx",
"args": [
"-y",
"@simonb97/server-win-cli",
"--config",
"path/to/your/config.json"
]
}
}
}구성 후 다음을 수행할 수 있습니다.
사용 가능한 도구를 사용하여 명령을 직접 실행합니다.
리소스 섹션에서 구성된 SSH 연결 및 서버 구성을 확인하세요.
제공된 도구를 통해 SSH 연결을 관리합니다.
서버는 JSON 구성 파일을 사용하여 동작을 사용자 지정합니다. 보안 제어, 셸 구성 및 SSH 연결에 대한 설정을 지정할 수 있습니다.
기본 구성 파일을 만들려면 다음 중 하나를 수행하세요.
a) config.json.example config.json 에 복사하거나
b) 실행:
npx @simonb97/server-win-cli --init-config ./config.json그런 다음 Claude Desktop 사용 섹션에 설명된 대로 --config 플래그를 설정하여 구성 파일을 가리키도록 합니다.
서버는 다음 위치에서 구성을 찾습니다(순서대로).
--config 플래그로 지정된 경로
현재 디렉토리의 ./config.json
사용자 홈 디렉토리의 ~/.win-cli-mcp/config.json
구성 파일을 찾을 수 없는 경우 서버는 기본(제한된) 구성을 사용합니다.
참고 : 기본 구성은 제한적이고 안전하게 설계되었습니다. 각 설정에 대한 자세한 내용은 구성 설정 섹션에서 확인하세요.
{
"security": {
"maxCommandLength": 2000,
"blockedCommands": [
"rm",
"del",
"rmdir",
"format",
"shutdown",
"restart",
"reg",
"regedit",
"net",
"netsh",
"takeown",
"icacls"
],
"blockedArguments": [
"--exec",
"-e",
"/c",
"-enc",
"-encodedcommand",
"-command",
"--interactive",
"-i",
"--login",
"--system"
],
"allowedPaths": ["User's home directory", "Current working directory"],
"restrictWorkingDirectory": true,
"logCommands": true,
"maxHistorySize": 1000,
"commandTimeout": 30,
"enableInjectionProtection": true
},
"shells": {
"powershell": {
"enabled": true,
"command": "powershell.exe",
"args": ["-NoProfile", "-NonInteractive", "-Command"],
"blockedOperators": ["&", "|", ";", "`"]
},
"cmd": {
"enabled": true,
"command": "cmd.exe",
"args": ["/c"],
"blockedOperators": ["&", "|", ";", "`"]
},
"gitbash": {
"enabled": true,
"command": "C:\\Program Files\\Git\\bin\\bash.exe",
"args": ["-c"],
"blockedOperators": ["&", "|", ";", "`"]
}
},
"ssh": {
"enabled": false,
"defaultTimeout": 30,
"maxConcurrentSessions": 5,
"keepaliveInterval": 10000,
"keepaliveCountMax": 3,
"readyTimeout": 20000,
"connections": {}
}
}구성 파일은 security , shells , ssh 세 가지 주요 섹션으로 나뉩니다.
{
"security": {
// Maximum allowed length for any command
"maxCommandLength": 1000,
// Commands to block - blocks both direct use and full paths
// Example: "rm" blocks both "rm" and "C:\\Windows\\System32\\rm.exe"
// Case-insensitive: "del" blocks "DEL.EXE", "del.cmd", etc.
"blockedCommands": [
"rm", // Delete files
"del", // Delete files
"rmdir", // Delete directories
"format", // Format disks
"shutdown", // Shutdown system
"restart", // Restart system
"reg", // Registry editor
"regedit", // Registry editor
"net", // Network commands
"netsh", // Network commands
"takeown", // Take ownership of files
"icacls" // Change file permissions
],
// Arguments that will be blocked when used with any command
// Note: Checks each argument independently - "cd warm_dir" won't be blocked just because "rm" is in blockedCommands
"blockedArguments": [
"--exec", // Execution flags
"-e", // Short execution flags
"/c", // Command execution in some shells
"-enc", // PowerShell encoded commands
"-encodedcommand", // PowerShell encoded commands
"-command", // Direct PowerShell command execution
"--interactive", // Interactive mode which might bypass restrictions
"-i", // Short form of interactive
"--login", // Login shells might have different permissions
"--system" // System level operations
],
// List of directories where commands can be executed
"allowedPaths": ["C:\\Users\\YourUsername", "C:\\Projects"],
// If true, commands can only run in allowedPaths
"restrictWorkingDirectory": true,
// If true, saves command history
"logCommands": true,
// Maximum number of commands to keep in history
"maxHistorySize": 1000,
// Timeout for command execution in seconds (default: 30)
"commandTimeout": 30,
// Enable or disable protection against command injection (covers ;, &, |, \`)
"enableInjectionProtection": true
}
}{
"shells": {
"powershell": {
// Enable/disable this shell
"enabled": true,
// Path to shell executable
"command": "powershell.exe",
// Default arguments for the shell
"args": ["-NoProfile", "-NonInteractive", "-Command"],
// Optional: Specify which command operators to block
"blockedOperators": ["&", "|", ";", "`"] // Block all command chaining
},
"cmd": {
"enabled": true,
"command": "cmd.exe",
"args": ["/c"],
"blockedOperators": ["&", "|", ";", "`"] // Block all command chaining
},
"gitbash": {
"enabled": true,
"command": "C:\\Program Files\\Git\\bin\\bash.exe",
"args": ["-c"],
"blockedOperators": ["&", "|", ";", "`"] // Block all command chaining
}
}
}{
"ssh": {
// Enable/disable SSH functionality
"enabled": false,
// Default timeout for SSH commands in seconds
"defaultTimeout": 30,
// Maximum number of concurrent SSH sessions
"maxConcurrentSessions": 5,
// Interval for sending keepalive packets (in milliseconds)
"keepaliveInterval": 10000,
// Maximum number of failed keepalive attempts before disconnecting
"keepaliveCountMax": 3,
// Timeout for establishing SSH connections (in milliseconds)
"readyTimeout": 20000,
// SSH connection profiles
"connections": {
// NOTE: these examples are not set in the default config!
// Example: Local Raspberry Pi
"raspberry-pi": {
"host": "raspberrypi.local", // Hostname or IP address
"port": 22, // SSH port
"username": "pi", // SSH username
"password": "raspberry", // Password authentication (if not using key)
"keepaliveInterval": 10000, // Override global keepaliveInterval
"keepaliveCountMax": 3, // Override global keepaliveCountMax
"readyTimeout": 20000 // Override global readyTimeout
},
// Example: Remote server with key authentication
"dev-server": {
"host": "dev.example.com",
"port": 22,
"username": "admin",
"privateKeyPath": "C:\\Users\\YourUsername\\.ssh\\id_rsa", // Path to private key
"keepaliveInterval": 10000,
"keepaliveCountMax": 3,
"readyTimeout": 20000
}
}
}
}실행 명령
지정된 셸에서 명령을 실행합니다.
입력:
shell (문자열): 사용할 셸("powershell", "cmd" 또는 "gitbash")
command (문자열): 실행할 명령
workingDir (선택적 문자열): 작업 디렉토리
실행에 실패하면 명령 출력을 텍스트로 반환하거나 오류 메시지를 반환합니다.
명령 기록 가져오기
실행된 명령의 기록을 가져옵니다
입력: limit (선택적 숫자)
출력과 함께 타임스탬프가 지정된 명령 기록을 반환합니다.
ssh_execute
SSH를 통해 원격 시스템에서 명령 실행
입력:
connectionId (문자열): 사용할 SSH 연결의 ID
command (문자열): 실행할 명령
실행에 실패하면 명령 출력을 텍스트로 반환하거나 오류 메시지를 반환합니다.
ssh_disconnect
SSH 서버에서 연결 해제
입력:
connectionId (문자열): 연결을 끊을 SSH 연결의 ID
확인 메시지를 반환합니다.
ssh_연결 생성
새로운 SSH 연결을 만듭니다
입력:
connectionId (문자열): 새 SSH 연결에 대한 ID
connectionConfig (객체): 호스트, 포트, 사용자 이름, 비밀번호 또는 privateKeyPath를 포함한 연결 구성 세부 정보
확인 메시지를 반환합니다.
ssh_연결 읽기
구성된 모든 SSH 연결을 읽습니다.
구성에서 모든 SSH 연결 목록을 반환합니다.
업데이트_ssh_연결
기존 SSH 연결 업데이트
입력:
connectionId (문자열): 업데이트할 SSH 연결의 ID
connectionConfig (객체): 새로운 연결 구성 세부 정보
확인 메시지를 반환합니다.
ssh_연결 삭제
SSH 연결 삭제
입력:
connectionId (문자열): 삭제할 SSH 연결의 ID
확인 메시지를 반환합니다.
get_current_directory
서버의 현재 작업 디렉토리를 가져옵니다
현재 작업 디렉토리 경로를 반환합니다.
SSH 연결
URI 형식: ssh://{connectionId}
민감한 정보가 가려진 연결 세부 정보가 포함되어 있습니다.
구성된 각 SSH 연결에 대한 하나의 리소스
예: ssh://raspberry-pi "raspberry-pi" 연결에 대한 구성을 보여줍니다.
SSH 구성
URI: ssh://config
전체 SSH 구성 및 모든 연결(암호는 마스크됨)이 포함되어 있습니다.
defaultTimeout, maxConcurrentSessions 및 연결 목록과 같은 설정을 표시합니다.
현재 디렉토리
URI: cli://currentdir
CLI 서버의 현재 작업 디렉토리를 포함합니다.
기본적으로 명령이 실행되는 경로를 표시합니다.
CLI 구성
URI: cli://config
CLI 서버 구성(민감한 데이터 제외)이 포함되어 있습니다.
보안 설정, 셸 구성 및 SSH 설정을 표시합니다.
다음 보안 기능은 서버에 하드코딩되어 있어 비활성화할 수 없습니다.
대소문자 구분 없이 명령 차단 : 모든 명령 차단은 대소문자를 구분하지 않습니다(예: "del"이 blockedCommands에 있으면 "DEL.EXE", "del.cmd" 등이 모두 차단됨)
스마트 경로 구문 분석 : 서버는 우회 시도를 방지하기 위해 전체 명령 경로를 구문 분석합니다("rm"이 차단된 경우 "C:\Windows\System32\rm.exe" 차단).
명령어 구문 분석 인텔리전스 : 거짓 양성 반응이 방지됩니다(예: "rm"이 blockedCommands에 있다는 이유만으로 "warm_dir"이 차단되지 않음)
입력 검증 : 모든 사용자 입력은 실행 전에 검증됩니다.
Shell 프로세스 관리 : 실행 또는 시간 초과 후 프로세스가 정상적으로 종료됩니다.
민감한 데이터 마스킹 : 비밀번호는 리소스에서 자동으로 마스킹됩니다(********로 대체됨)
이러한 보안 기능은 config.json 파일을 통해 구성할 수 있습니다.
명령 차단 : blockedCommands 배열에 지정된 명령이 차단됩니다(기본값에는 rm, del, format과 같은 위험한 명령이 포함됩니다)
인수 차단 : blockedArguments 배열에 지정된 인수가 차단됩니다(기본값에는 잠재적으로 위험한 플래그가 포함됨)
명령 주입 보호 : 명령 체이닝을 방지합니다(기본적으로 enableInjectionProtection: true 통해 활성화됨)
작업 디렉토리 제한 : 명령 실행을 지정된 디렉토리로 제한합니다(기본적으로 restrictWorkingDirectory: true 를 통해 활성화됨)
명령 길이 제한 : 최대 명령 길이를 제한합니다(기본값: 2000자)
명령 시간 초과 : 너무 오래 실행되는 명령을 종료합니다(기본값: 30초)
명령 로깅 : 명령 기록을 기록합니다(기본적으로 logCommands: true 를 통해 활성화됨)
이는 기능이 아니지만 알아두어야 할 중요한 보안 고려 사항입니다.
환경 액세스 : 명령은 민감한 정보를 포함할 수 있는 환경 변수에 액세스할 수 있습니다.
파일 시스템 액세스 : 명령은 허용된 경로 내에서 파일을 읽고 쓸 수 있습니다. 민감한 데이터에 대한 액세스를 방지하려면 allowedPaths 신중하게 구성하세요.
이 프로젝트는 MIT 라이선스에 따라 라이선스가 부여되었습니다. 자세한 내용은 라이선스 파일을 참조하세요.
Create a new SSH connection
| Name | Required | Description | Default |
|---|---|---|---|
| connectionId | No | ID of the SSH connection | |
| connectionConfig | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden but only states the action without behavioral details. It doesn't disclose if this requires authentication, has side effects (e.g., storing credentials), involves rate limits, or what happens on success/failure. For a tool that likely handles sensitive SSH data, this is a significant gap in transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with zero waste—'Create a new SSH connection' is front-loaded and appropriately sized for its minimal content. It earns its place by stating the core purpose without unnecessary elaboration.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (SSH connection creation with nested objects), no annotations, no output schema, and incomplete parameter coverage, the description is inadequate. It doesn't explain what 'create' means operationally, return values, or error conditions, leaving critical gaps for a tool that likely involves network operations and credential handling.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 50% (2 parameters total, with descriptions for nested properties but not top-level ones). The description adds no parameter semantics beyond the schema, which already documents host, port, etc., but doesn't clarify the relationship between 'connectionId' and 'connectionConfig'. Baseline 3 is appropriate as the schema does moderate work.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Create a new SSH connection' clearly states the action (create) and resource (SSH connection), but it's vague about what 'create' entails—does it establish a live connection, store configuration, or both? It doesn't differentiate from siblings like 'update_ssh_connection' or 'ssh_connect' (if present), leaving ambiguity in scope.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. With siblings like 'update_ssh_connection', 'ssh_disconnect', and 'read_ssh_connections', the description lacks context on prerequisites (e.g., whether a connection must not exist) or when to choose creation over updating, offering no usage instructions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Delete an existing SSH connection
| Name | Required | Description | Default |
|---|---|---|---|
| connectionId | Yes | ID of the SSH connection to delete |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It states this is a deletion operation but doesn't mention whether it's reversible, what permissions are required, what happens to associated resources, or error conditions. For a destructive operation with zero annotation coverage, this is inadequate.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with zero wasted words. It's appropriately sized for a simple deletion tool and gets straight to the point without unnecessary elaboration.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a destructive operation with no annotations and no output schema, the description is insufficient. It doesn't explain what 'delete' entails (permanent removal? soft delete?), what gets returned, or error handling. Given the complexity of SSH connection management and lack of structured data, more context is needed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with the single parameter 'connectionId' fully documented in the schema. The description doesn't add any additional meaning about the parameter beyond what the schema already provides, so it meets the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Delete') and target resource ('an existing SSH connection'), providing specific verb+resource pairing. However, it doesn't differentiate this from sibling tools like 'ssh_disconnect' or 'update_ssh_connection', which might have overlapping functionality.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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 like 'ssh_disconnect' or 'update_ssh_connection', nor does it mention prerequisites (e.g., needing an existing connection ID). It simply states what the tool does without context for selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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"
}| 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) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of disclosing behavior. It gives examples but does not mention return values, exit codes, error handling, side effects, environment specifics, or security implications. For a command execution tool, this is insufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The opening one-sentence description is concise and front-loaded. The three examples are redundant in structure but serve to illustrate cross-shell syntax. Each sentence earns its place, though the examples could be trimmed to one or two without loss.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool that executes arbitrary system commands, there is no mention of output format, timeouts, working directory defaults, or safety considerations. The presence of sibling ssh_execute suggests a need to clarify local vs remote execution, which is absent. The examples help but do not fill all gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema already covers 100% of parameters, but the description adds value through concrete examples showing valid shell values, command syntax, and workingDir formatting (e.g., Windows paths vs Git Bash paths). This enhances understanding beyond the schema's terse descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool executes a command in a specified shell (powershell, cmd, or gitbash), which is a specific verb+resource. It is distinguishable from siblings like get_command_history and ssh_execute, though it does not explicitly call out these differences. The mention of the shell options adds specificity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is given on when to use this tool versus alternatives such as ssh_execute (remote execution) or get_command_history. The examples imply usage but do not provide context, prerequisites, or exclusions. This is a clear gap.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get the history of executed commands
Example usage:
{
"limit": 5
}Example response:
[
{
"command": "Get-Process",
"output": "...",
"timestamp": "2024-03-20T10:30:00Z",
"exitCode": 0
}
]| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Maximum number of history entries to return (default: 10, max: 1000) |
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 adds transparency by showing a detailed example response with fields (command, output, timestamp, exitCode), which clarifies the return format. However, it does not explicitly state whether history is session-scoped, how results are ordered, or that it has no side effects. Given the absence of annotations, there are notable but not critical gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise: a single opening sentence plus two compact JSON examples. The purpose is front-loaded, and every element adds value—the example usage demonstrates the parameter, and the example response shows the expected output structure. No redundancy or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple one-parameter, no-output-schema tool, the description is quite complete: it states the purpose, shows how to invoke it, and provides a representative response. Minor omissions like ordering or session scope are not critical for a list-history tool. The example response effectively substitutes for an output schema, making the tool actionable for an agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already fully documents the 'limit' parameter with default (10) and max (1000) values, providing 100% coverage. The description's example usage (limit: 5) reinforces the parameter but adds no new semantic meaning beyond the schema. Baseline 3 is appropriate because the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a clear verb+resource statement: 'Get the history of executed commands'. It distinguishes itself from sibling tools like execute_command (execution) and ssh_execute (remote execution) by focusing specifically on retrieval of prior commands. The example response reinforces the purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides a clear usage context: to retrieve previously executed commands, with an example showing the optional limit parameter. It does not explicitly state when not to use it, but the purpose is self-evident and no competing history tools exist among siblings. No explicit exclusions are given, but this is clearly a read-only counterpart to the execution siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get the current working directory
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description does not disclose any behavioral traits beyond the name. There is no mention of side effects, permissions, or return format. The description carries the full burden but adds no extra context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence with no wasted words. It is appropriately sized for a tool with no parameters and a simple purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has no parameters, no output schema, and a straightforward action, the description is complete enough. It explains what the tool does without needing further details.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There are zero parameters and schema coverage is 100% (vacuously). The description adds no additional parameter semantics because there are none. Baseline for zero parameters is 4.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action and resource: 'Get the current working directory'. It is a specific verb-noun pair that distinguishes itself from sibling tools like execute_command or set_current_directory.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit when-to-use or when-not-to-use guidance is provided. However, the purpose is straightforward and the tool is a simple getter, so implied usage is clear. No alternatives or exclusions are mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Read all SSH connections
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
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 states 'read all SSH connections,' implying a read-only operation, but doesn't specify if it returns active connections, historical data, permissions required, or any side effects like rate limits. This leaves significant gaps for a tool with zero annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with no wasted words. It's front-loaded and directly states the tool's purpose, making it highly concise and well-structured for quick understanding.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the lack of annotations and output schema, the description is incomplete. It doesn't explain what 'SSH connections' entails (e.g., active sessions, configured profiles), the return format, or behavioral traits like safety or limitations. For a read operation with no structured context, this leaves the agent with insufficient information.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description doesn't add parameter details, which is appropriate, earning a baseline score of 4 for adequately handling the lack of parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('read') and resource ('SSH connections'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'get_command_history' or 'ssh_execute', which might also involve reading SSH-related data, so it doesn't reach the highest score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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. With siblings like 'get_command_history' or 'ssh_execute' that might retrieve related information, there's no indication of context, prerequisites, or exclusions to help the agent choose appropriately.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Disconnect from an SSH server
Example usage:
{
"connectionId": "raspberry-pi"
}Use this to cleanly close SSH connections when they're no longer needed.
| Name | Required | Description | Default |
|---|---|---|---|
| connectionId | Yes | ID of the SSH connection to disconnect |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must carry the full burden. It mentions 'cleanly close' but doesn't disclose side effects like what happens to associated sessions, idempotency, or error behavior. It's minimally adequate but not rich.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is short and includes a practical JSON example, which helps the agent. It repeats the concept slightly ('Disconnect' and 'close SSH connections'), but overall it's well-structured and efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple one-parameter tool with no output schema, the description is adequate. It provides an example and clear use case. It doesn't cover errors or edge cases, but given the low complexity, this is not a significant gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with the parameter described as 'ID of the SSH connection to disconnect'. The example usage adds an illustrative value (raspberry-pi) but doesn't add semantic meaning beyond the schema, so baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Disconnect' and the resource 'SSH connection/server', which distinguishes it from siblings like ssh_execute and execute_command. The example usage reinforces the exact action.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It says 'when they're no longer needed', providing clear context for when to use this tool. It doesn't explicitly mention alternatives or when not to use, but the sibling tool names imply the distinction, so a slight deduction is warranted.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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"
}
}
}
}| Name | Required | Description | Default |
|---|---|---|---|
| connectionId | Yes | ID of the SSH connection to use | |
| command | Yes | Command to execute |
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 that SSH must be enabled in config.json and gives an example connection, which is useful. However, it does not disclose the command execution behavior (e.g., output format, error handling, potential destructive side-effects) or that it uses the specified password for authentication.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is structured and efficient, with a one-sentence purpose followed by illustrative JSON examples. The config block is large but necessary to show the setup requirements. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema and no annotations, the description should explain what the tool returns or what 'execute' entails. It does neither, though it does provide configuration context. For a command execution tool, the lack of mention of output or error behavior leaves a moderate gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema descriptions are minimal ('Command to execute', 'ID of the SSH connection to use'). The description adds meaningful value by showing an example usage and the config structure, clarifying that connectionId refers to a key in the 'connections' object and command is a shell string.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Execute a command on a remote host via SSH', using a specific verb and resource. It distinguishes itself from sibling tools like ssh_disconnect (manage connection) and get_command_history (retrieve history).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides a concrete example and configuration requirement, implying when to use the tool (when you have a configured SSH connection and need to run a command). However, it does not explicitly state when to use it over alternatives like execute_command, nor does it provide exclusion criteria.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Update an existing SSH connection
| Name | Required | Description | Default |
|---|---|---|---|
| connectionId | No | ID of the SSH connection to update | |
| connectionConfig | No |
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 an update operation, implying mutation, but doesn't disclose any behavioral traits like permission requirements, whether changes are reversible, what happens to unspecified fields, error conditions, or rate limits. This is inadequate for a mutation tool with zero annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that gets straight to the point with zero wasted words. It's appropriately sized for a basic tool description and is perfectly front-loaded with the essential information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a mutation tool with no annotations, no output schema, and incomplete parameter documentation (50% schema coverage), the description is insufficient. It doesn't address what the tool returns, error conditions, side effects, or provide enough context about the update operation. The description should do more to compensate for the lack of structured metadata.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 50% (only 'connectionId' has a description in the schema, while 'connectionConfig' and its nested properties lack descriptions). The description adds no parameter semantics beyond what's implied by the tool name - it doesn't explain what fields can be updated, how to structure the config object, or provide examples. The baseline is 3 since the schema covers some parameters, but the description doesn't compensate for the coverage gap.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Update') and resource ('an existing SSH connection'), making the purpose immediately understandable. It distinguishes from 'create_ssh_connection' by specifying 'existing', but doesn't explicitly differentiate from other sibling tools like 'delete_ssh_connection' beyond the verb difference.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
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 prerequisites (e.g., needing an existing connection ID), when not to use it, or how it relates to sibling tools like 'create_ssh_connection' or 'delete_ssh_connection' beyond the basic verb difference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
create_ssh_connectiondelete_ssh_connectionexecute_commandget_command_historyget_current_directoryread_ssh_connectionsssh_disconnectssh_executeupdate_ssh_connectionScored across 9 tools
Most tools have distinct purposes: SSH connection management (create/delete/read/update), SSH operations (execute/disconnect), and local shell operations (execute_command/get_history/get_directory). However, execute_command and ssh_execute both execute commands but in different contexts (local vs remote), which could cause minor confusion if not carefully distinguished by the agent.
All tool names follow a consistent verb_noun pattern with snake_case throughout (e.g., create_ssh_connection, execute_command, get_command_history). The naming is predictable and readable, with no deviations in style or convention.
With 9 tools, the count is well-scoped for a Windows CLI server covering SSH management and command execution. Each tool earns its place by addressing specific operations like connection lifecycle, remote execution, and local shell interactions, without being overly sparse or bloated.
The tool set provides good coverage for SSH connection CRUD (create, read, update, delete) and remote command execution, plus local shell operations. A minor gap exists in local file operations (e.g., read/write files) which could enhance the CLI functionality, but core workflows are adequately supported without dead ends.
Termalin's hosted MCP server. Claude, ChatGPT or any MCP client runs commands, moves files over SFTP, queries databases and reads server metrics and monitoring alerts on your servers, keylessly through Termalin Connectors: no SSH key is handed over and no inbound port is opened. Per-host command policy and an audit log. Needs a termal.in Pro or Team account (new accounts start with a 14-day Pro trial).
The Remote MCP server acts as a standardized bridge between LLM applications (like Claude, ChatGPT, and Cursor) and external services, enabling AI agents to access external tools and resources. Its primary capability is providing a centralized search tool to discover other MCP servers and their respective tools. Unlike local implementations, it runs remotely with OAuth authentication and permission controls for security.
Remote MCP server exposing your Node Command fleet (files, shell, processes, browser) to AI hosts.
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
