Powershell.MCP

MCP开发工具

提供方 yotsuda

开发工具 未标注 API Key 社区 / 第三方 Claude DesktopClaudeCursorCodex
查看接入方式

Enables PowerShell console to function as an MCP server for Claude Desktop.

一句话选型结论

按资料字段整理

Powershell.MCP 属于开发工具类 MCP 服务器,传输方式未标注,API Key,可直接接入 Claude Desktop、Claude、Cursor 等,有可直接执行的安装命令。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

分类开发工具 传输方式未标注 鉴权API Key 部署方式未标注
GitHub 星标 未标注 仓库热度,无公开仓库时显示未标注
工具数 未标注 暴露给模型的工具数量
资源 / 提示词 0 / 0 资源与提示词模板数量
维护方 社区 / 第三方 核验等级 仅资料核对

工具与能力

开发工具
数量来自来源目录的标注,具体工具清单以官方文档为准
工具数量未标注暴露给模型可调用的工具个数
资源数量0可读取的资源条目
提示词数量0内置提示词模板数量

能力标签

支持客户端

适用场景

powershellai agentai integration

安装与配置

未标注 API Key
上游未给出传输方式
C:\\Users\\YourName\\Documents\\PowerShell\\Modules\\PowerShell.MCP\\1.4.1\\bin\\win-x64\\PowerShell.MCP.Proxy.exe

这条命令只是入口,具体启动参数请按官方文档补齐,不要直接照搬到别的服务器。

  1. 1
    准备运行环境

    按官方文档确认运行环境(常见为 Node.js 或 Python),装好后再执行安装命令。

  2. 2
    安装服务

    复制上面的安装命令执行;命令里带占位符的位置,换成自己的密钥或路径。

  3. 3
    写入客户端配置

    在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,让新配置生效。

  4. 4
    验证是否可用

    连接成功后随便调一个只读工具,确认能返回结果,再接入正式流程。

典型使用场景

3 类
按分类与标签整理的常见用法,具体以官方文档为准
代码与仓库操作

在对话里直接查代码、提 issue、走 PR,省掉来回切工具。

本地命令与脚本

把构建、测试、格式化这类重复命令交给模型执行。

接口联调与测试

让模型调你的接口、跑一遍用例,快速定位问题。

选择建议

选之前先看这几条
按条目字段给出的判断,不替你决定用不用

值得选的地方

  • 有现成的安装命令,不用自己找入口,照着跑就能起服务。
  • 已适配 Claude Desktop、Claude、Cursor,换客户端不用重新研究配置。

先想清楚的地方

  • 使用前要准备好API Key对应的凭据,并按最小权限配置。
  • 资料没标注工具数量,实际能力要装好后确认。
  • 版本更新与行为细节以官方仓库为准。

更适合

  • 需要在开发工具场景里让模型直接调用外部能力的人。
  • 已经在用 Claude Desktop、Claude 的用户,接入路径最短。
  • 想先快速试一下、能接受在本地或自有环境跑服务的人。

不太适合

  • 不方便管理密钥或第三方授权的人。
  • 需要厂商级 SLA 和技术支持的生产环境。

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
Powershell.MCP当前 未标注 未标注 未标注 有 未标注
Git 838e2ec1 12 stdio · 本地进程 本地部署 有 2026-05-17
Markitdown MCP 2c653a5f 1 stdio · 本地进程 本地部署 有 2026-05-17
JavaGuide 未标注 stdio · 本地进程 本地部署 有 2026-04-11
awesome-claude-skills 未标注 stdio · 本地进程 本地部署 有 2026-04-26
Context7 831acf40 未标注 stdio · 本地进程 本地部署 有 2026-05-17

服务器档案

开发工具
字段来自项目仓库与公开索引,中文说明由本站标注
提供方yotsuda上游标注的维护方 yotsuda
分类开发工具本站按上游分类展示
连接方式未标注上游未给出传输方式
鉴权方式API Key远程服务建议用最小权限凭据
维护方社区 / 第三方核验等级 仅资料核对
包名 / 运行时未标注 · Cross-platform本地安装时用到的包标识与运行时
部署类型未标注上游给出的部署形态
最近核验未标注上游最后核验时间

详细介绍

29.9 KB
来自项目仓库与上游目录的原文,未做删改

PowerShell.MCP

Security Warning: This module provides complete PowerShell access to your system. Malicious use could result in severe damage. Use responsibly and only in trusted environments.

Overview

The universal MCP server—one installation gives AI access to 10,000+ PowerShell modules and any CLI tool.

PowerShell.MCP connects AI assistants to the entire PowerShell ecosystem through a single MCP server. You and AI collaborate in the same PowerShell console—every command the AI runs appears there as it runs, and a transcript can record all of it (see Auditing an AI Session).

Need bash, a language REPL, a SQL console, or a debugger instead? If you can't install PowerShell 7, or you'd rather drive another shell (bash, cmd, zsh), a language REPL (python, node, racket, lua, …), a SQL console (sqlite3, …), or a language debugger (pdb, jdb, perldb), check out ripple — the same shared-console concept generalized to any REPL, with unified ConPTY-based consoles running side by side.

Why PowerShell.MCP?

A universal gateway to the PowerShell ecosystem.

PowerShell.MCP takes a different approach from service-specific MCP servers. Rather than providing curated tools for individual services, it gives AI assistants direct access to PowerShell—letting them use the same modules and CLI tools that professionals use every day.

This means:
- One MCP server replaces many — no need for separate servers for each service
- Immediate access to 10,000+ modules on PowerShell Gallery without waiting for dedicated MCP servers
- Cross-service workflows combining multiple services in a single pipeline
- API exploration — prototype and verify API behavior with immediate feedback before writing production code
- Self-evolving capabilities — AI writes PowerShell scripts that both AI and users can execute, continuously extending what's possible
- Industry-standard skills — commands you learn transfer directly to your own work

Examples: PowerShell pipeline processing

"Show me bug issues from the PowerShell repo with their authors"```powershell
gh issue list --repo PowerShell/PowerShell --json title,author,labels |
ConvertFrom-Json |
Where-Object { $.labels.name -contains "Issue-Bug" } |
Select-Object title, @{N='by';E={$
.author.login}}


*"List my running Azure VMs with their sizes"*```powershell
Get-AzVM -Status | Where-Object PowerState -eq "VM running" |
    Select-Object Name, @{N='Size';E={$_.HardwareProfile.VmSize}}, Location

"Check if GitHub's API returns rate limit info"```powershell
Invoke-RestMethod https://api.github.com/rate_limit |
Select-Object -ExpandProperty rate


*"Get the current user's Windows username via Win32 API"*```powershell
Add-Type -MemberDefinition '[DllImport("advapi32.dll")] public static extern bool GetUserName(System.Text.StringBuilder sb, ref int len);' -Name Win32 -Namespace API
$sb = [System.Text.StringBuilder]::new(256); $len = 256
[API.Win32]::GetUserName($sb, [ref]$len); $sb.ToString()

PowerShell.MCP complements your existing MCP setup by providing a flexible, general-purpose foundation.

What Makes It Powerful

🖥️ Multi-Client Architecture
- Each client instance gets its own exclusive console—run multiple Claude Code sessions in parallel
- Safe parallel operation with no resource conflicts
- Unique window titles (e.g., "#12345 Taxi") for easy identification
- Get-MCPOwner cmdlet shows which client owns the current console

🤝 Shared Console Experience
- You and AI collaborate in the same PowerShell session with full transparency
- Every command AI executes appears in your console in real-time
- You can respond to interactive prompts directly in the console
- Short commands are added to the console history on Windows—learn by watching AI work

🔄 Persistent Session State
- Authenticate once, stay authenticated: Azure, AWS, Microsoft 365, and more
- Modules, variables, and functions persist across commands
- No re-initialization overhead

🌐 Universal Access
- PowerShell Gallery: 10,000+ modules including Az, AWS.Tools, Microsoft.Graph
- Any CLI tool: git, docker, kubectl, terraform, gh, az cli, aws cli
- AI learns syntax automatically via Get-Help

🔗 Pipeline Composability
- Describe what you want in natural language—AI constructs the optimal pipeline
- "Top 5 largest logs" → Get-ChildItem *.log · Sort-Object Length -Descending · Select-Object -First 5
- Chain any commands across any services

⚡ Instant Execution
- Commands execute immediately in an existing console
- No process startup overhead per command
- Real-time streaming output

🔐 Enterprise-Ready Security
- Local named pipes by default; a TCP port only while remote control is on — on the remote machine (Enable-MCPRemoteControl), or on this one while the AI waits for a console to dial in (accept_remote_console) (Remote Control)
- Every command visible, and recordable with Start-Transcript or Script Block Logging (Auditing an AI Session)
- Integrates with existing security policies

🔒 Secrets stay with you, not the AI
- Interactive prompts (Read-Host -AsSecureString, Get-Credential, MFA codes) hide input from the AI
- Enter passphrases for code-signing, gpg, ssh-add, sudo, cloud CLI MFA — keystrokes go to the program, never to AI's output stream
- AI orchestrates the workflow ("build, sign, push the tag"); you supply the secret at the right moment
- Impossible with stdin-piped MCP shells, where the AI must somehow feed the secret in

Architecture

Eleven tools — six for consoles on this machine, five for a console on another machine; waiting is shared:

Tool Purpose
This machine
start_console Reuse a standby console, or launch a new one
get_current_location Get the current directory, available drives, and system info (OS, PowerShell version, user, culture)
execute_command Execute any PowerShell command or CLI tool (literal text via var1–var8)
wait_for_completion Wait for busy consoles — here or on a remote machine — to finish and collect their cached output
cancel Interrupt the command currently running in the console (stops the pipeline and sends Ctrl+C)
close_console Kill a console by PID (e.g. one paused at an interactive prompt), returning any output it still holds
Another machine (Remote console)
connect_remote_console Connect to a console that is listening (Enable-MCPRemoteControl) with its pairing code
accept_remote_console Let a console dial in (for machines behind NAT or a firewall) — returns the Enable-MCPRemoteControl -ConnectTo line to run there, or, where nothing can be installed, one line to paste
execute_remote_command Execute a command in the remote console (a result that outran its timeout comes back with wait_for_completion, or with the next tool call of any kind)
cancel_remote_command Send Ctrl+C to the remote console
disconnect_remote_console Disconnect from one remote console (or stop accepting)

Quick Start

Prerequisites

All platforms require:
- PowerShell 7.4+ (installation guide)
- Claude Desktop, Claude Code, or any MCP client

Platform OS Requirements
Windows Windows 10/11 or Windows Server 2016+
Linux Ubuntu 22.04+, Debian 11+, RHEL 8+, or another distribution PowerShell 7.4 supports; a GUI desktop to see the console
macOS macOS 12 (Monterey)+, Intel or Apple Silicon

Windows Setup

1. Open PowerShell 7

Press Win + R, type pwsh, press Enter

2. Install PowerShell.MCP```powershell

Install-PSResource PowerShell.MCP


#### 3. Configure your MCP client

**For Claude Code:**```powershell
Register-PwshToClaudeCode

It then asks whether to disable Claude Code's built-in Bash and PowerShell tools, so that every command runs in the console you can see (recommended, and the default answer). -DisableBuiltInShellTools or -KeepBuiltInShellTools answers without asking.

For Claude Desktop:```powershell
Register-PwshToClaudeDesktop


**For other MCP clients:** Run `Get-MCPProxyPath -Escape` to get the JSON-escaped executable path, then add it to your client's configuration file manually.

#### 4. Restart your MCP client

Linux Setup

#### 1. Install PowerShell 7```bash
# Ubuntu/Debian
sudo apt-get update
sudo apt-get install -y wget apt-transport-https software-properties-common
source /etc/os-release
wget -q https://packages.microsoft.com/config/ubuntu/$VERSION_ID/packages-microsoft-prod.deb
sudo dpkg -i packages-microsoft-prod.deb
sudo apt-get update
sudo apt-get install -y powershell

2. Install PowerShell.MCP, set permissions, and configure your MCP client```powershell

Run in PowerShell (pwsh)

Install-PSResource PowerShell.MCP
chmod +x "$(Get-MCPProxyPath)"


**For Claude Code:**```powershell
Register-PwshToClaudeCode

It then asks whether to disable Claude Code's built-in Bash and PowerShell tools, so that every command runs in the console you can see (recommended, and the default answer). -DisableBuiltInShellTools or -KeepBuiltInShellTools answers without asking.

For Claude Desktop:```powershell
Register-PwshToClaudeDesktop


**For other MCP clients:** Run `Get-MCPProxyPath -Escape` to get the JSON-escaped executable path, then add it to your client's configuration file manually.

#### 3. Restart your MCP client

macOS Setup

#### 1. Install PowerShell 7```bash
brew install --cask powershell
# If the cask is unavailable, install from GitHub Release (on an Intel Mac, use osx-x64 instead of osx-arm64):
# curl -sSL -o /tmp/powershell.tar.gz https://github.com/PowerShell/PowerShell/releases/download/v7.5.4/powershell-7.5.4-osx-arm64.tar.gz
# sudo mkdir -p /usr/local/microsoft/powershell/7
# sudo tar zxf /tmp/powershell.tar.gz -C /usr/local/microsoft/powershell/7
# sudo chmod +x /usr/local/microsoft/powershell/7/pwsh
# sudo ln -sf /usr/local/microsoft/powershell/7/pwsh /usr/local/bin/pwsh

2. Install PowerShell.MCP, set permissions, and configure your MCP client```powershell

Run in PowerShell (pwsh)

Install-PSResource PowerShell.MCP
chmod +x "$(Get-MCPProxyPath)"


**For Claude Code:**```powershell
Register-PwshToClaudeCode

It then asks whether to disable Claude Code's built-in Bash and PowerShell tools, so that every command runs in the console you can see (recommended, and the default answer). -DisableBuiltInShellTools or -KeepBuiltInShellTools answers without asking.

For Claude Desktop:```powershell
Register-PwshToClaudeDesktop


**For other MCP clients:** Run `Get-MCPProxyPath -Escape` to get the JSON-escaped executable path, then add it to your client's configuration file manually.

#### 3. Restart your MCP client

### Updating

Every installed version lives in its own folder, so the proxy path your MCP client launches changes with each update. Re-register after updating: otherwise the client keeps starting the previous version's proxy, and commands fail with *"PowerShell.MCP.Proxy version is outdated"*.

#### 1. Update the module
Open a **new** PowerShell 7 window (not one of the PowerShell.MCP consoles) and run:```powershell
Update-PSResource PowerShell.MCP

2. Re-register from another new window

A window that has already loaded PowerShell.MCP keeps the old version, so open one more new window, which loads the version just installed:```powershell
chmod +x "$(Get-MCPProxyPath)" # Linux / macOS only: the new proxy needs the execute bit again

Register-PwshToClaudeCode # Claude Code
Register-PwshToClaudeDesktop # Claude Desktop

Both replace the existing `pwsh` entry and keep the arguments and environment variables already set on it, such as `--no-profile`. **For other MCP clients:** replace the path in your configuration with the output of `Get-MCPProxyPath -Escape`.

#### 3. Close the old consoles and restart your MCP client
Close the PowerShell.MCP console windows (titled like `#12345 Taxi`) — each keeps running the version it was started with — then quit and restart your MCP client.

To see what is installed, and remove a version no console is using any more:```powershell
Get-InstalledPSResource PowerShell.MCP
Uninstall-PSResource PowerShell.MCP -Version <old version>

Configuration

Lean consoles (--no-profile)

By default, every console the proxy launches loads your PowerShell $PROFILE (prompt, aliases, PSReadLine, theme) — these are real interactive shells, not just automation targets. Pass --no-profile to start them with -NoProfile instead, for faster startup and a clean, deterministic environment.

Claude Code:```powershell
claude mcp remove pwsh -s user # if pwsh is already registered: 'claude mcp add' refuses an existing name
claude mcp add pwsh -s user -- "$(Get-MCPProxyPath)" --no-profile

From then on `Register-PwshToClaudeCode` keeps the flag, including when you re-register after an update.

**Claude Desktop / other MCP clients:** add an `args` array with `--no-profile` to the `pwsh` entry in your config (`Register-PwshToClaudeDesktop` keeps it when it re-registers):```json
"mcpServers": {
  "pwsh": {
    "command": "...PowerShell.MCP.Proxy.exe",
    "args": ["--no-profile"]
  }
}

> The headless / CI launcher always uses -NoProfile regardless of this flag.

Idle consoles close themselves

When consoles pile up, an owned console that neither the AI nor you have used for 10 minutes prints a warning and closes itself 60 seconds later. The most recently used console of each session is always kept, and a console that is busy, waiting at a prompt, still holding output that has not been collected, has text typed at its prompt, or has an unfinished background job (Start-Job, &) is never closed. Typing anything, or any AI command, cancels a pending close. A console started by a sub-agent (is_subagent=true) is not kept: once idle it closes like any other, since a finished sub-agent never comes back for it.

A console that closes itself leaves a note, and the AI's next tool call reports it: Console #N was closed: it closed itself after 10 min without use …. A console that disappeared any other way (its window closed, its process ended) is reported too, without the reason. Either way the line says what else went with it: jobs the console was running end with the console, while a process started with Start-Process keeps running.

Several AI sessions on one machine

Each MCP client session runs its own proxy, and a proxy sees only the consoles it started or claimed: a console's pipe is named after the proxy that owns it, so two sessions (say two Claude Code windows) never share, borrow or close each other's consoles, even on the same server registration. The only consoles up for grabs are unowned ones — a window you opened yourself and ran Import-Module PowerShell.MCP in, or one whose proxy has exited — and the first session that needs a console claims it (the window says so). Idle closing is per session as well: each session keeps its own most recently used console, and a session's consoles are never counted against another's.

Variable Default Meaning
POWERSHELL_MCP_STANDBY_REAP_MINUTES 10 Idle minutes before the warning; 0 turns closing off
POWERSHELL_MCP_STANDBY_REAP_GRACE_SECONDS 60 Seconds between the warning and the close

Set these as user or system environment variables (Windows: System Properties → Environment Variables, or setx; macOS / Linux: your login shell's profile), not in your MCP client's env block. Each console is a new terminal window rather than a child of the proxy, so a variable set only for the proxy generally does not reach it.

Timeout ceiling

A blocking call is capped to what your MCP client will actually wait for: 170 seconds for Claude Code and 50 seconds for any other client. Nothing is lost when the cap is reached: the command keeps running, and its result arrives with the next tool call. If your client waits longer than 50 seconds, raise the cap with POWERSHELL_MCP_TIMEOUT_CEILING (seconds, at most 170). This one is read by the proxy, so set it in your MCP client's env block:```json
"mcpServers": {
"pwsh": {
"command": "...PowerShell.MCP.Proxy.exe",
"env": { "POWERSHELL_MCP_TIMEOUT_CEILING": "120" }
}
}


With the Claude Code CLI, pass it as `-e POWERSHELL_MCP_TIMEOUT_CEILING=120` to `claude mcp add`; `Register-PwshToClaudeCode` and `Register-PwshToClaudeDesktop` keep it when they re-register.

---

### Admin work on this machine

The consoles the AI starts are not elevated. For admin work, open PowerShell 7 **as Administrator** and run `Import-Module PowerShell.MCP`; then close the AI's own consoles (or let the AI close them with `close_console`). With none of its own left, the next command goes to your elevated console, whose title shows `Administrator:`. That first command stops once to say where the console is; the AI re-issues it there. No remote control is involved.

### Remote console (another machine)

The AI can also drive a console on **another machine** — a test VM, a build box, a colleague's PC with that colleague watching (they run `Enable-MCPRemoteControl` and read you the code, below). If that console is elevated, so is the AI, which makes it a practical tool for **defensive work**: auditing a server, reading its event logs, checking what it exposes, hardening it, with the person responsible watching every command.

*"Audit this VM's security, read-only"* — against a lab VM in Azure, reached through a port its owner had opened to one address, one session went from the Security log (2,015 failed RDP logons in three hours, no account lockout configured) to the local accounts and password policy, the listening ports checked against what is reachable from outside, SQL Server's version and login mode, Defender, TLS settings and persistence points, and ended with a report the team that owns the VM template could act on, in about ten minutes. That kind of review is usually postponed; attackers' tooling is already automated, and the gap is on the defenders' side.

On the remote machine, install PowerShell 7.4+ (`winget install Microsoft.PowerShell` on Windows; other platforms), then in PowerShell 7:```powershell
Install-Module PowerShell.MCP -RequiredVersion <version>   # once; the version your own machine runs — ask the AI
Import-Module PowerShell.MCP
Enable-MCPRemoteControl -AllowFrom 192.168.0.10           # the AI's machine; TCP port 42777 by default, -Port to change

On Linux and macOS the remote console can be a plain SSH session — no desktop is needed on that side.

It asks you to confirm — saying which user the AI will act as, and whether elevated — then prints a pairing code (XXXX-XXXX-XXXX, good for one connection within 10 minutes), its host name and IP addresses. Give those to the AI on your machine — "connect to the remote console at 192.168.0.20 with code 7Q4K-M2XP-H9RT". It calls connect_remote_console, then runs commands there with execute_remote_command: the same semantics as execute_command (a persistent session, var1–var8, the text-file cmdlets, cancel_remote_command; a command that outruns its timeout is collected by the same wait_for_completion as a local one, or arrives with the AI's next tool call), with that machine's paths, in a window the person there can see. A Read-Host is answered by that person. While the AI is connected, every prompt there starts with [AI from ].

If the remote machine cannot take an inbound connection (NAT, a cloud NSG, a firewall you cannot open), turn it around: the AI calls accept_remote_console on your machine and gives you Enable-MCPRemoteControl -ConnectTo : -Code to run there. Only an outbound connection is needed there; the inbound port is on your machine — Windows asks once whether to allow PowerShell.MCP.Proxy.exe through the firewall (private networks is enough for a machine on your LAN; a VM or Windows Sandbox on your own machine comes through a Hyper-V virtual switch, which Windows usually counts as public). Same pairing, roles swapped.

If PowerShell 7 and PowerShell.MCP cannot be installed there the usual way — a Windows machine with no internet access, say — the same answer gives one line to paste there instead, into PowerShell 7 if it is installed, otherwise into Windows PowerShell. It fetches PowerShell.MCP (the same build as yours) and, if PowerShell 7.4+ is not installed, a portable PowerShell 7 from your machine, and checks their hashes — nothing to install, no admin right, no internet access needed on the remote side. Pasted into PowerShell 7.4+, remote control starts in that same window, so a console you opened as Administrator is the one the AI drives; pasted into Windows PowerShell (or an older PowerShell 7), it opens a PowerShell 7 window that dials in. Either way the console asks you to confirm before it dials. If you let the AI install PowerShell 7 and PowerShell.MCP there for later use (it asks you first: for this user, or for all users), the script lists what it will install and asks again; from then on the short Enable-MCPRemoteControl line is enough. The line is too long to type, so it needs a clipboard that reaches that machine.

  • Inbound TCP 42777 must be allowed through the remote machine's firewall (listening mode); if connecting fails, the AI gives you a New-NetFirewallRule line scoped to its address, and the line that removes it. In dial-out mode the port to open is on your machine instead.
  • One proxy at a time per console. One proxy drives up to four remote consoles at once, one per machine — say, to compare servers or to work on both ends of a connection. With more than one, every remote tool call names its console (remote: the host it was connected with, or port N for one that dialed in); a call that does not is refused, never sent to a guessed one. A dropped connection reconnects by itself. A pairing code works once: after disconnect_remote_console the console shows a new one, and remote control stops by itself if nobody connects within 10 minutes. Disable-MCPRemoteControl (or Remove-Module) ends it at any time.
  • A listening console ends remote control after five forged pairing attempts (a mistyped code does not count). A connection that takes the console's proof of the code and hangs up — a mistyped code on the AI's side, or someone collecting it to guess codes offline — is not counted, but the console shows its address (once per address and code; after three addresses, one line for the rest).
  • Security: TLS with a certificate made for the session and a handshake bound to that certificate and to the code. The code is short-lived on purpose: anyone who reaches the port can try codes offline. Meant for a LAN or VPN — do not expose the port to the Internet. What an attacker on the network can and cannot do: SECURITY.md.
  • Both machines must run the same PowerShell.MCP version. If they differ — and neither may be the latest — run Update-Module PowerShell.MCP on both, or on the older one with -RequiredVersion. If Update-Module refuses (a module not installed with Install-Module, such as one the one-line bootstrap installed), use Install-Module PowerShell.MCP -RequiredVersion -Force. After updating your own machine, restart the MCP client.

Granted, not taken. Remote control starts only when a person at that machine runs Enable-MCPRemoteControl or pastes the line and answers Yes. It refuses to start where nobody could answer (a service, a script without a console, -NonInteractive), shows [AI from ] on every prompt and Administrator: in the title of an elevated window, and ends with Disable-MCPRemoteControl or by itself once no AI has been connected for 10 minutes (what the AI changed meanwhile stays, as with any admin work). Intrusion tooling is built to be the opposite: hidden and persistent. Like any tool, it cannot stop code already running on a machine from starting it out of sight — but it gives such code nothing it did not have, and SECURITY.md lists how to spot it. Paste a line only if you asked an AI for it yourself: "paste this into PowerShell" is also how lures begin, and the console's question names the machine it will connect to. To help on a colleague's PC, use the listening mode, so no line is handed over.

Data on the remote machine can be written by an attacker. Event logs, user names in failed-logon records, file contents, web pages: when the AI reads them, it reads text that someone else chose, possibly crafted to look like instructions — with whatever rights that console has, and with the AI's access to your machine as well. The server tells the AI to treat it as data and to connect only to hosts and codes you typed. Pair only with machines you trust that far; for audits and incident response, ask for read-only work first and have the AI confirm before any change; to keep a record, run Start-Transcript in the remote console before pairing (see Auditing an AI Session).

First-Time Demo

Experience PowerShell.MCP's capabilities:

  • "Open pwsh and show what it can do in a colorful, dynamic, and fun demo"
  • "Try out different styles of notifications using the BurntToast module"
  • "Automate Notepad: type text and smoothly move the window in a circle"
  • "How does it feel now that you have a tool like PowerShell.MCP?"

After trying these demos, try the built-in prompts below or ask AI to explain any command.

Built-in Prompts

PowerShell.MCP includes 2 prompts that teach AI workflows it does not otherwise know (a companion module, and the built-in speech synthesizer). In Claude Code, run them as slash commands, with what you want as the argument:```text
/pwsh:show_interactive_map hot springs in Kanto
/pwsh:foreign_language_dictation English, short sentences, normal speed


The argument is optional; without it, AI asks what you want. Other MCP clients offer them in their prompt list, if the client shows MCP prompts.

---

### 🗣️ Foreign Language Dictation Training
**Best for:** Improving listening skills in foreign languages

Plays sentences aloud from the PowerShell console and checks what you type back. Windows only (uses the built-in speech synthesizer).

**Examples:** `/pwsh:foreign_language_dictation English dictation at beginner level` • `/pwsh:foreign_language_dictation Japanese conversation at the zoo`

---

### 🗺️ Show Interactive Map
**Best for:** Visualizing geographic data or locations

Generates interactive HTML maps with markers, descriptions, and optional 3D display using PowerShell.Map module.

**Examples:** `/pwsh:show_interactive_map major Roman battles in chronological order` • `/pwsh:show_interactive_map hot springs in Japan`

        Roman Battle Locations

        Colosseum 3D Visualization

---

## Platform Notes

### Windows
- PSReadLine module is automatically loaded for enhanced console experience
- Full color support for PowerShell output

### Linux
- A GUI desktop environment (GNOME, KDE, XFCE, etc.) is needed to see and type into the console. Without a supported terminal emulator the console still starts, headless: the AI can run commands, but there is no window to watch or type into.
- Supported terminal emulators: gnome-terminal, konsole, xfce4-terminal, xterm, lxterminal, mate-terminal, terminator, tilix, alacritty, kitty
- PSReadLine is replaced by a simpler line editor of the module's own: on Linux, PSReadLine keeps the timer that runs AI commands from firing while the prompt waits for input

### macOS
- Works with Terminal.app (default)
- PSReadLine is replaced by a simpler line editor of the module's own, for the same reason as on Linux
- Both Apple Silicon (M1/M2/M3/M4) and Intel Macs are supported

---

## Limitations

- **AI Command Cancellation**: AI can interrupt a running command with the `cancel` tool — it stops a runaway/long-running PowerShell pipeline and sends Ctrl+C to a native CLI. A command stuck in a non-interruptible blocking call, or a console paused at an interactive prompt, can't be stopped that way — abandon it with the `close_console` tool.
- **User Command Privacy**: Commands you execute are not visible to AI assistants.
- **External Command Colors**: Color output from some CLI tools may not be preserved (git colors are supported).
- **Command History**: On Windows, AI-executed commands of one or two lines are added to the console's PSReadLine history; longer multi-line commands are intentionally excluded to avoid history bloat. On Linux and macOS, AI-executed commands are not added to history.
- **Programs that read the console at startup (Windows)**: Windows lets only one reader at a time take from a console's input buffer, and the prompt holds one for as long as an AI command runs. A program that probes console input while starting up therefore queues behind the prompt and does not return until a key is pressed. It is rare — common CLIs (git, node, npm, python, dotnet, curl, ssh) are unaffected; LilyPond is a known case. Run such a program detached with its standard input from `NUL`: `cmd /d /s /c " < NUL > out.log 2>&1"`. On a timeout the console names the stalled process and repeats this form. See docs/Console-Input-Starvation.md.

## Enterprise Deployment (WDAC / Device Guard)

Starting with v1.7.7, `PowerShell.MCP.dll` and `PowerShell.MCP.Proxy.exe`
(win-x64) are Authenticode-signed with the **yotsuda code-signing
certificate**, shared across all yotsuda OSS projects.

For installation instructions (personal PC, AD GPO deployment, WDAC policy
configuration) and the public certificate file itself, see:

**→ github.com/yotsuda/code-signing**

The certificate thumbprint is also published in each GitHub release's notes.```powershell
# Quick verify on installed binaries

…(正文过长,页面只展示前面部分,完整内容见仓库)

常见问题

7 问
答案由本站依据条目字段整理,不引用上游原文
Powershell.MCP 怎么安装?

在客户端按下面的安装命令接入:C:\\Users\\YourName\\Documents\\PowerShell\\Modules\\PowerShell.MCP\\1.4.1\\bin\\win-x64\\PowerShell.MCP.Proxy.exe。装完在客户端配置里引用同一个包或端点。

Powershell.MCP 怎么在 Claude Desktop、Claude、Cursor 里配置?

它的传输方式未标注,在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,配置才会生效。

Powershell.MCP 收费吗?

本站不代收费用,也没有标注具体价格。是否收费取决于服务本身和背后的接口额度,正式使用前按官方说明确认。

Powershell.MCP 需要 API Key 吗?

资料标注需要API Key认证,使用前准备好对应凭据,并按最小权限配置。

Powershell.MCP 支持哪些客户端?

资料标注支持 Claude Desktop、Claude、Cursor、Codex、Zed;其他客户端只要能配置 MCP Server,也能用同样的命令或地址接入。

Powershell.MCP 能提供哪些能力?

资料显示能力标签包括 powershell、ai agent、ai integration。具体工具清单以官方文档为准。

Powershell.MCP 需要什么运行环境?

运行时为 Cross-platform。

热门专题

按标签挑服务器
全部专题 →

服务器信息以作者仓库与官方文档为准;分类、传输方式与鉴权方式的中文说明为中文整理,最近核验 未标注。