Windowsシステム上で安全なコマンドラインインタラクションを実現するMCPサーバー。PowerShell、CMD、Git Bashシェル、そしてSSH経由のリモートシステムへの制御されたアクセスを可能にします。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に追加します:
{
"mcpServers": {
"windows-cli": {
"command": "npx",
"args": ["-y", "@simonb97/server-win-cli"]
}
}
}特定の設定ファイルで使用する場合は、 --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 3 つの主要なセクションに分かれています。
{
"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_切断
SSHサーバーから切断する
入力：
connectionId (文字列): 切断するSSH接続のID
確認メッセージを返す
SSH接続を作成する
新しいSSH接続を作成する
入力:
connectionId (文字列): 新しいSSH接続のID
connectionConfig (オブジェクト): ホスト、ポート、ユーザー名、パスワードまたは privateKeyPath を含む接続構成の詳細
確認メッセージを返す
read_ssh_connections
設定されたすべてのSSH接続を読み取る
設定からすべてのSSH接続のリストを返します
アップデート_ssh_接続
既存のSSH接続を更新する
入力:
connectionId (文字列): 更新するSSH接続のID
connectionConfig (オブジェクト): 新しい接続構成の詳細
確認メッセージを返します
SSH接続の削除
SSH接続を削除する
入力：
connectionId (文字列): 削除するSSH接続のID
確認メッセージを返す
現在のディレクトリを取得する
サーバーの現在の作業ディレクトリを取得する
現在の作業ディレクトリのパスを返します
SSH接続
URI 形式: ssh://{connectionId}
機密情報がマスクされた接続の詳細が含まれています
構成されたSSH接続ごとに1つのリソース
例: ssh://raspberry-pi 「raspberry-pi」接続の設定を表示します
SSH設定
URI: ssh://config
全体的な SSH 構成とすべての接続 (パスワードはマスクされています) が含まれます
defaultTimeout、maxConcurrentSessions、接続リストなどの設定を表示します
現在のディレクトリ
URI: cli://currentdir
CLIサーバーの現在の作業ディレクトリが含まれます
デフォルトでコマンドが実行されるパスを表示します
CLI設定
URI: cli://config
CLI サーバー構成が含まれます (機密データは除く)
セキュリティ設定、シェル構成、SSH設定を表示します
次のセキュリティ機能はサーバーにハードコードされており、無効にすることはできません。
大文字と小文字を区別しないコマンド ブロッキング: すべてのコマンド ブロッキングは大文字と小文字を区別しません (例: 「DEL.EXE」、「del.cmd」などは、blockedCommands に「del」が含まれている場合すべてブロックされます)
スマート パス解析: サーバーは完全なコマンド パスを解析してバイパスの試みを防止します (「rm」がブロックされている場合は「C:\Windows\System32\rm.exe」もブロックします)
コマンド解析インテリジェンス: 誤検知を回避します (例: 「warm_dir」は「rm」が blockedCommands にあるからといってブロックされるわけではありません)
入力検証: すべてのユーザー入力は実行前に検証されます
シェルプロセス管理: プロセスは実行後またはタイムアウト後に適切に終了されます
機密データのマスキング: リソース内のパスワードは自動的にマスクされます (******** に置き換えられます)
これらのセキュリティ機能は、config.json ファイルを通じて構成できます。
コマンドブロッキング: blockedCommands配列で指定されたコマンドがブロックされます (デフォルトでは、rm、del、format などの危険なコマンドが含まれます)
引数のブロック: blockedArguments配列で指定された引数はブロックされます (デフォルトでは潜在的に危険なフラグが含まれます)
コマンドインジェクション保護: コマンドチェーンを防止します ( enableInjectionProtection: trueによりデフォルトで有効)
作業ディレクトリの制限: コマンドの実行を指定されたディレクトリに制限します ( restrictWorkingDirectory: trueによりデフォルトで有効)
コマンドの長さ制限: コマンドの最大長を制限します (デフォルト: 2000 文字)
コマンドタイムアウト: 実行時間が長すぎるコマンドを終了します (デフォルト: 30 秒)
コマンドログ: コマンド履歴を記録します ( logCommands: trueによりデフォルトで有効)
これらは機能ではありませんが、知っておくべき重要なセキュリティ上の考慮事項です。
環境アクセス: コマンドは環境変数にアクセスする可能性があり、そこには機密情報が含まれている可能性があります。
ファイルシステムアクセス: コマンドは許可されたパス内のファイルの読み取り/書き込みが可能です。機密データへのアクセスを防ぐため、 allowedPathsを慎重に構成してください。
このプロジェクトは MIT ライセンスに基づいてライセンスされています - 詳細についてはLICENSEファイルを参照してください。
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 full burden for behavioral disclosure. While it shows example usage, it doesn't disclose critical behavioral traits: whether this executes commands with system privileges, potential security implications, whether commands run synchronously or asynchronously, error handling, or output format. The examples hint at execution but don't provide transparency about the tool's actual behavior.
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 appropriately sized and front-loaded with the core purpose statement. The three examples are helpful but somewhat repetitive in structure. Every sentence (and example) earns its place by demonstrating different shell usage, though some redundancy exists across examples.
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 this is a potentially dangerous command execution tool with no annotations and no output schema, the description is incomplete. It lacks critical context about security implications, permissions required, execution environment, error handling, and return format. For a tool that could execute arbitrary system commands, this represents significant gaps in contextual 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?
Schema description coverage is 100%, providing complete parameter documentation. The description adds minimal value beyond the schema through the examples, which illustrate parameter usage but don't explain semantics like shell-specific command syntax requirements or working directory path formats. The baseline score of 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.
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'), explicitly listing the three supported shells (powershell, cmd, gitbash). It distinguishes itself from sibling tools like 'ssh_execute' by focusing on local shell execution rather than remote SSH execution.
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 clear context for when to use this tool (for executing commands in local shells) through the examples, but doesn't explicitly state when not to use it or name alternatives. It implies usage for local command execution vs. remote SSH execution (sibling 'ssh_execute'), but lacks explicit guidance on choosing between this and other siblings.
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 of behavioral disclosure. It states the tool retrieves history but doesn't cover critical aspects: what 'executed commands' refers to (e.g., commands from 'execute_command' tool only, all server commands, system-wide), whether it requires specific permissions, how it handles pagination beyond the limit parameter, or if there are rate limits. The example response hints at output format but lacks explicit 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with a clear purpose statement, but the example usage and response occupy most of the text without adding significant explanatory value beyond the schema. While not verbose, the examples could be more concise or integrated with additional guidance. The structure is adequate but could be improved by trimming redundant examples.
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's complexity (retrieving command history) and lack of annotations and output schema, the description is incomplete. It doesn't explain the scope of 'executed commands' (e.g., tied to specific tools or sessions), behavioral constraints, or error handling. The example response provides some output format insight, but without an output schema, more detail on return values and structure is needed for adequate completeness.
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 'limit' parameter fully documented in the schema (type, description with default and max). The description adds no additional parameter semantics beyond what's in the schema—it only shows an example usage with 'limit': 5, which aligns with but doesn't expand on the schema. This meets the baseline of 3 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 tool's purpose as 'Get the history of executed commands' with a specific verb ('Get') and resource ('history of executed commands'). It distinguishes from siblings like 'execute_command' or 'ssh_execute' by focusing on historical retrieval rather than execution. However, it doesn't explicitly differentiate from other potential history-related tools that might exist in the future.
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., whether commands must have been executed via this server), exclusions, or relationships with sibling tools like 'execute_command' (which might populate this history). The example usage shows a parameter but doesn't explain context for its application.
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, so the description carries full burden. It states what the tool does but doesn't disclose behavioral traits such as whether it's read-only (implied by 'Get'), what permissions are required, if it has side effects, or what format the output returns. This leaves significant gaps for an agent to understand 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence with zero waste. It's front-loaded with the essential information and appropriately sized for a simple tool with no parameters, making it highly 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?
Given the tool's simplicity (0 parameters, no annotations, no output schema), the description is minimally adequate. It states the purpose but lacks context about usage, behavioral details, or output format. For such a straightforward tool, this might suffice, but it doesn't provide complete guidance for an agent in the broader SSH/command execution context.
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 tool has 0 parameters, and the schema description coverage is 100% (though empty). The description doesn't need to add parameter details, so it appropriately avoids redundancy. A baseline of 4 is applied since no parameters exist, and the description doesn't introduce confusion.
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 ('Get') and resource ('current working directory'), making the tool's purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'get_command_history' or 'read_ssh_connections' which might also retrieve information, 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. It doesn't mention context like needing to know the directory for executing commands or navigating files, nor does it reference sibling tools that might serve related purposes in the SSH/command execution context.
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 provided, the description carries the full burden of behavioral disclosure. It describes the action ('cleanly close SSH connections') but lacks details on error handling, side effects (e.g., what happens to active sessions), or prerequisites (e.g., requires an existing connection). It adds some context but leaves gaps in behavioral understanding.
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 front-loaded with the core purpose, followed by a concise example and usage guidance. Every sentence earns its place, with no redundant or unnecessary information, making it highly efficient and well-structured.
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's moderate complexity (disconnecting connections), no annotations, and no output schema, the description is mostly complete but could benefit from more behavioral details (e.g., error cases or confirmation of success). It adequately covers purpose and usage but has minor gaps in transparency.
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 100% description coverage, with the parameter 'connectionId' fully documented. The description does not add any additional semantic information beyond what the schema provides (e.g., format examples or constraints), so it meets the baseline for high schema coverage without extra value.
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 specific action ('Disconnect from') and resource ('an SSH server'), distinguishing it from siblings like 'delete_ssh_connection' (which likely removes connection configuration) and 'create_ssh_connection' (which establishes connections). The purpose is unambiguous and well-defined.
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 explicitly states when to use this tool ('when they're no longer needed') and provides a clear example of usage. It differentiates from siblings by focusing on disconnecting active connections rather than managing connection configurations (e.g., delete_ssh_connection) or executing commands (e.g., ssh_execute).
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 discloses that SSH configuration is required and shows an example, but does not mention critical behavioral traits such as authentication needs (e.g., password/key-based), potential security risks, execution timeouts, error handling, or output format. For a tool that executes commands remotely, 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 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; however, they earn their place by clarifying usage and prerequisites without unnecessary verbosity.
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 of SSH command execution, no annotations, and no output schema, the description is incomplete. It lacks information on return values (e.g., stdout, stderr, exit codes), error conditions, security implications, and behavioral details like interactive vs. non-interactive execution. The example helps but does not compensate for these 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?
Schema description coverage is 100%, so the schema already documents both parameters ('connectionId' and 'command') with descriptions. The description adds minimal value beyond the schema by showing an example usage that illustrates parameter values, but does not provide additional semantic context like command syntax constraints or connectionId enumeration details.
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 specific action ('Execute a command') and resource ('on a remote host via SSH'), distinguishing it from siblings like 'create_ssh_connection' (setup) or 'get_command_history' (retrieval). The example usage reinforces this purpose with concrete parameters.
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 implies usage by showing an example with 'connectionId' and 'command', and mentions configuration prerequisites, but does not explicitly state when to use this tool versus alternatives like 'execute_command' (which might be a sibling with unclear differentiation) or provide exclusions. The context is clear but lacks explicit guidance on tool selection.
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. Dates show when Glama detected each change.
create_ssh_connectiondelete_ssh_connectionexecute_commandget_command_historyget_current_directoryread_ssh_connectionsssh_disconnectssh_executeupdate_ssh_connectionMost 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.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
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.
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
Cloud-hosted MCP server for secure AI access to enterprise data sources via CData Connect AI.
MCP server unifying ERPs, CRMs, APIs and knowledge base for Claude, ChatGPT and Gemini.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/simon-ami/win-cli-mcp-server'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
