@mokoconsulting/mcp-windows 3.0.0

package/src/tools/clipboard.ts

@@ -0,0 +1,138 @@
+/* Copyright (C) 2026 Moko Consulting <hello@mokoconsulting.tech>
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ * Tools: windows_clipboard_get (#16), windows_clipboard_set (#17)
+ */
+
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import { runPowerShell } from '../shell.js';
+
+export function registerClipboardTools(server: McpServer): void {
+	server.tool(
+		'windows_clipboard_get',
+		'Read clipboard contents: text, file list, or image (returned as base64).',
+		{},
+		async () => {
+			// PowerShell must run in STA mode for clipboard access
+			const ps = `
+powershell.exe -NoProfile -STA -Command {
+  Add-Type -AssemblyName System.Windows.Forms
+  $data = [System.Windows.Forms.Clipboard]::GetDataObject()
+  if (-not $data) { Write-Output '{"type":"empty","content":"Clipboard is empty"}'; return }
+
+  # Check for files
+  if ($data.ContainsFileDropList()) {
+    $files = [System.Windows.Forms.Clipboard]::GetFileDropList()
+    $list = @()
+    foreach ($f in $files) { $list += $f }
+    $json = @{ type = 'files'; content = $list } | ConvertTo-Json -Compress
+    Write-Output $json
+    return
+  }
+
+  # Check for image
+  if ($data.ContainsImage()) {
+    $img = [System.Windows.Forms.Clipboard]::GetImage()
+    $ms = New-Object System.IO.MemoryStream
+    $img.Save($ms, [System.Drawing.Imaging.ImageFormat]::Png)
+    $b64 = [Convert]::ToBase64String($ms.ToArray())
+    $ms.Dispose()
+    $img.Dispose()
+    $json = @{ type = 'image'; content = $b64 } | ConvertTo-Json -Compress
+    Write-Output $json
+    return
+  }
+
+  # Text
+  if ($data.ContainsText()) {
+    $text = [System.Windows.Forms.Clipboard]::GetText()
+    $json = @{ type = 'text'; content = $text } | ConvertTo-Json -Compress
+    Write-Output $json
+    return
+  }
+
+  Write-Output '{"type":"unknown","content":"Clipboard contains unsupported format"}'
+}`;
+
+			const result = await runPowerShell(ps, { timeout: 10000 });
+			if (result.exitCode !== 0) {
+				return { content: [{ type: 'text', text: `Error: ${result.stderr}` }], isError: true };
+			}
+
+			try {
+				const data = JSON.parse(result.stdout);
+
+				if (data.type === 'image') {
+					return {
+						content: [
+							{ type: 'text' as const, text: 'Clipboard contains an image:' },
+							{ type: 'image' as const, data: data.content, mimeType: 'image/png' },
+						],
+					};
+				}
+
+				if (data.type === 'files') {
+					const files = Array.isArray(data.content) ? data.content : [data.content];
+					return {
+						content: [{ type: 'text', text: `Clipboard contains ${files.length} file(s):\n${files.join('\n')}` }],
+					};
+				}
+
+				return {
+					content: [{ type: 'text', text: data.content || '(empty)' }],
+				};
+			} catch {
+				return { content: [{ type: 'text', text: result.stdout || '(empty clipboard)' }] };
+			}
+		},
+	);
+
+	server.tool(
+		'windows_clipboard_set',
+		'Set clipboard contents: text, file list, or clear.',
+		{
+			text: z.string().optional().describe('Text to copy to clipboard'),
+			files: z.array(z.string()).optional().describe('File paths to copy to clipboard'),
+			clear: z.boolean().optional().describe('Clear the clipboard'),
+		},
+		async ({ text, files, clear }) => {
+			if (clear) {
+				const result = await runPowerShell(`
+powershell.exe -NoProfile -STA -Command {
+  Add-Type -AssemblyName System.Windows.Forms
+  [System.Windows.Forms.Clipboard]::Clear()
+  "Clipboard cleared"
+}`);
+				return { content: [{ type: 'text', text: result.stdout || result.stderr }] };
+			}
+
+			if (text) {
+				// Escape for PowerShell here-string
+				const escaped = text.replace(/'/g, "''");
+				const result = await runPowerShell(`
+powershell.exe -NoProfile -STA -Command {
+  Add-Type -AssemblyName System.Windows.Forms
+  [System.Windows.Forms.Clipboard]::SetText('${escaped}')
+  "Copied $([System.Windows.Forms.Clipboard]::GetText().Length) chars to clipboard"
+}`);
+				return { content: [{ type: 'text', text: result.stdout || result.stderr }] };
+			}
+
+			if (files && files.length > 0) {
+				const pathList = files.map(f => `$fc.Add('${f.replace(/'/g, "''")}')`).join('; ');
+				const result = await runPowerShell(`
+powershell.exe -NoProfile -STA -Command {
+  Add-Type -AssemblyName System.Windows.Forms
+  $fc = New-Object System.Collections.Specialized.StringCollection
+  ${pathList}
+  [System.Windows.Forms.Clipboard]::SetFileDropList($fc)
+  "Copied $($fc.Count) file(s) to clipboard"
+}`);
+				return { content: [{ type: 'text', text: result.stdout || result.stderr }] };
+			}
+
+			return { content: [{ type: 'text', text: 'Provide text, files, or clear.' }], isError: true };
+		},
+	);
+}

package/src/tools/config.ts

@@ -0,0 +1,105 @@
+/* Copyright (C) 2026 Moko Consulting <hello@mokoconsulting.tech>
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ * Tool: windows_mcp_config (#40)
+ */
+
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import { readFile, writeFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { homedir } from 'node:os';
+
+const CONFIG_PATH = resolve(homedir(), '.mcp_windows.json');
+
+interface McpConfig {
+	blockedCommands: string[];
+	allowedDirectories: string[];
+	outputLineLimit: number;
+	commandTimeout: number;
+}
+
+const DEFAULT_CONFIG: McpConfig = {
+	blockedCommands: ['Format-Volume', 'Clear-Disk', 'Remove-Partition'],
+	allowedDirectories: [],
+	outputLineLimit: 5000,
+	commandTimeout: 30000,
+};
+
+let currentConfig: McpConfig | null = null;
+
+async function loadConfig(): Promise<McpConfig> {
+	if (currentConfig) return currentConfig;
+	try {
+		const raw = await readFile(CONFIG_PATH, 'utf-8');
+		currentConfig = { ...DEFAULT_CONFIG, ...JSON.parse(raw) };
+	} catch {
+		currentConfig = { ...DEFAULT_CONFIG };
+	}
+	return currentConfig!;
+}
+
+async function saveConfig(config: McpConfig): Promise<void> {
+	await writeFile(CONFIG_PATH, JSON.stringify(config, null, 2), 'utf-8');
+	currentConfig = config;
+}
+
+export function registerConfigTools(server: McpServer): void {
+	server.tool(
+		'windows_mcp_config',
+		'Get or set mcp_windows configuration (blocked commands, allowed directories, output limits).',
+		{
+			action: z.enum(['get', 'set']).default('get').describe('Get or set config'),
+			key: z.string().optional().describe('Config key to set (blockedCommands, allowedDirectories, outputLineLimit, commandTimeout)'),
+			value: z.string().optional().describe('Value to set (JSON for arrays, number for limits)'),
+		},
+		async ({ action, key, value }) => {
+			const config = await loadConfig();
+
+			if (action === 'get') {
+				return {
+					content: [{
+						type: 'text',
+						text: [
+							`mcp_windows configuration (${CONFIG_PATH}):`,
+							``,
+							`Blocked commands: ${config.blockedCommands.join(', ') || '(none)'}`,
+							`Allowed directories: ${config.allowedDirectories.length > 0 ? config.allowedDirectories.join(', ') : '(unrestricted)'}`,
+							`Output line limit: ${config.outputLineLimit}`,
+							`Command timeout: ${config.commandTimeout}ms`,
+						].join('\n'),
+					}],
+				};
+			}
+
+			if (!key || value === undefined) {
+				return { content: [{ type: 'text', text: 'Set requires key and value.' }], isError: true };
+			}
+
+			switch (key) {
+				case 'blockedCommands':
+				case 'allowedDirectories':
+					try {
+						(config as unknown as Record<string, unknown>)[key] = JSON.parse(value);
+					} catch {
+						return { content: [{ type: 'text', text: `Value must be a JSON array (e.g. ["cmd1","cmd2"])` }], isError: true };
+					}
+					break;
+				case 'outputLineLimit':
+				case 'commandTimeout': {
+					const num = Number(value);
+					if (isNaN(num) || num < 0) {
+						return { content: [{ type: 'text', text: 'Value must be a positive number.' }], isError: true };
+					}
+					(config as unknown as Record<string, unknown>)[key] = num;
+					break;
+				}
+				default:
+					return { content: [{ type: 'text', text: `Unknown key: ${key}. Valid: blockedCommands, allowedDirectories, outputLineLimit, commandTimeout` }], isError: true };
+			}
+
+			await saveConfig(config);
+			return { content: [{ type: 'text', text: `Set ${key} = ${value}` }] };
+		},
+	);
+}

package/src/tools/dialog.ts

@@ -0,0 +1,87 @@
+/* Copyright (C) 2026 Moko Consulting <hello@mokoconsulting.tech>
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ * Tool: windows_dialog (#21)
+ */
+
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import { runPowerShell } from '../shell.js';
+
+export function registerDialogTools(server: McpServer): void {
+	server.tool(
+		'windows_dialog',
+		'Show system dialogs: message box, input prompt, file/folder picker.',
+		{
+			type: z.enum(['message', 'input', 'file_open', 'file_save', 'folder']).describe('Dialog type'),
+			title: z.string().default('mcp_windows').describe('Dialog title'),
+			message: z.string().optional().describe('Message text (for message/input)'),
+			buttons: z.enum(['ok', 'okcancel', 'yesno', 'yesnocancel']).default('ok').describe('Buttons (for message)'),
+			filter: z.string().optional().describe('File filter (for file dialogs, e.g. "Text files|*.txt|All files|*.*")'),
+			default_path: z.string().optional().describe('Default path/filename'),
+		},
+		async ({ type, title, message, buttons, filter, default_path }) => {
+			let ps: string;
+
+			switch (type) {
+				case 'message': {
+					const btnMap: Record<string, number> = { ok: 0, okcancel: 1, yesno: 4, yesnocancel: 3 };
+					ps = `
+Add-Type -AssemblyName System.Windows.Forms
+$result = [System.Windows.Forms.MessageBox]::Show('${(message || '').replace(/'/g, "''")}', '${title.replace(/'/g, "''")}', ${btnMap[buttons]})
+$result.ToString()`;
+					break;
+				}
+
+				case 'input':
+					ps = `
+Add-Type -AssemblyName Microsoft.VisualBasic
+$result = [Microsoft.VisualBasic.Interaction]::InputBox('${(message || 'Enter value:').replace(/'/g, "''")}', '${title.replace(/'/g, "''")}', '${(default_path || '').replace(/'/g, "''")}')
+if ($result) { $result } else { '__CANCELLED__' }`;
+					break;
+
+				case 'file_open':
+					ps = `
+Add-Type -AssemblyName System.Windows.Forms
+$dlg = New-Object System.Windows.Forms.OpenFileDialog
+$dlg.Title = '${title.replace(/'/g, "''")}'
+${filter ? `$dlg.Filter = '${filter.replace(/'/g, "''")}'` : ''}
+${default_path ? `$dlg.InitialDirectory = '${default_path.replace(/'/g, "''")}'` : ''}
+$dlg.Multiselect = $false
+if ($dlg.ShowDialog() -eq 'OK') { $dlg.FileName } else { '__CANCELLED__' }`;
+					break;
+
+				case 'file_save':
+					ps = `
+Add-Type -AssemblyName System.Windows.Forms
+$dlg = New-Object System.Windows.Forms.SaveFileDialog
+$dlg.Title = '${title.replace(/'/g, "''")}'
+${filter ? `$dlg.Filter = '${filter.replace(/'/g, "''")}'` : ''}
+${default_path ? `$dlg.FileName = '${default_path.replace(/'/g, "''")}'` : ''}
+if ($dlg.ShowDialog() -eq 'OK') { $dlg.FileName } else { '__CANCELLED__' }`;
+					break;
+
+				case 'folder':
+					ps = `
+Add-Type -AssemblyName System.Windows.Forms
+$dlg = New-Object System.Windows.Forms.FolderBrowserDialog
+$dlg.Description = '${(message || title).replace(/'/g, "''")}'
+${default_path ? `$dlg.SelectedPath = '${default_path.replace(/'/g, "''")}'` : ''}
+if ($dlg.ShowDialog() -eq 'OK') { $dlg.SelectedPath } else { '__CANCELLED__' }`;
+					break;
+			}
+
+			const result = await runPowerShell(ps, { timeout: 120000 }); // Long timeout — user interaction
+			if (result.exitCode !== 0) {
+				return { content: [{ type: 'text', text: `Error: ${result.stderr}` }], isError: true };
+			}
+
+			const output = result.stdout.trim();
+			if (output === '__CANCELLED__') {
+				return { content: [{ type: 'text', text: 'Dialog cancelled by user.' }] };
+			}
+
+			return { content: [{ type: 'text', text: output }] };
+		},
+	);
+}

package/src/tools/display.ts

@@ -0,0 +1,285 @@
+/* Copyright (C) 2026 Moko Consulting <hello@mokoconsulting.tech>
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ * Tools: windows_display_get (#9), windows_display_set (#10), windows_screenshot (#11)
+ */
+
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import { runPowerShell } from '../shell.js';
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { tmpdir } from 'node:os';
+
+export function registerDisplayTools(server: McpServer): void {
+	server.tool(
+		'windows_display_get',
+		'Get display configuration: resolution, refresh rate, scaling, multi-monitor layout, HDR status.',
+		{},
+		async () => {
+			const ps = `
+Add-Type -AssemblyName System.Windows.Forms
+
+$screens = [System.Windows.Forms.Screen]::AllScreens
+$monitors = Get-CimInstance -Namespace root\\wmi -ClassName WmiMonitorBasicDisplayParams -ErrorAction SilentlyContinue
+$videoCtrl = Get-CimInstance Win32_VideoController
+
+$i = 0
+$screens | ForEach-Object {
+  $s = $_
+  $vc = $videoCtrl | Where-Object { $_.Name -match $s.DeviceName -or $true } | Select-Object -First 1
+  $dpiScale = [math]::Round(($s.Bounds.Width / $s.WorkingArea.Width) * 100, 0)
+
+  # Try to get real scaling from registry
+  $regScale = $null
+  try {
+    $regPath = "HKCU:\\Control Panel\\Desktop\\PerMonitorSettings"
+    if (Test-Path $regPath) {
+      $regScale = (Get-ChildItem $regPath -ErrorAction SilentlyContinue | Select-Object -Index $i | Get-ItemProperty -ErrorAction SilentlyContinue).DpiValue
+    }
+  } catch {}
+
+  [PSCustomObject]@{
+    Index = $i
+    Name = $s.DeviceName
+    Primary = $s.Primary
+    Resolution = "$($s.Bounds.Width)x$($s.Bounds.Height)"
+    RefreshRate = if ($vc) { "$($vc.CurrentRefreshRate) Hz" } else { 'Unknown' }
+    Scaling = if ($regScale) { "$($regScale)%" } else { 'System default' }
+    Position = "($($s.Bounds.X), $($s.Bounds.Y))"
+    WorkArea = "$($s.WorkingArea.Width)x$($s.WorkingArea.Height)"
+    BitsPerPixel = if ($vc) { $vc.CurrentBitsPerPixel } else { $null }
+  }
+  $i++
+} | ConvertTo-Json -Depth 3 -Compress`;
+
+			const result = await runPowerShell(ps, { timeout: 10000 });
+			if (result.exitCode !== 0) {
+				return { content: [{ type: 'text', text: `Error: ${result.stderr}` }], isError: true };
+			}
+
+			const displays = Array.isArray(JSON.parse(result.stdout)) ? JSON.parse(result.stdout) : [JSON.parse(result.stdout)];
+			const lines = displays.map((d: { Index: number; Name: string; Primary: boolean; Resolution: string; RefreshRate: string; Scaling: string; Position: string; WorkArea: string }) =>
+				[
+					`Monitor ${d.Index}: ${d.Name}${d.Primary ? ' (Primary)' : ''}`,
+					`  Resolution: ${d.Resolution} @ ${d.RefreshRate}`,
+					`  Scaling: ${d.Scaling}`,
+					`  Position: ${d.Position}`,
+					`  Work area: ${d.WorkArea}`,
+				].join('\n'),
+			);
+
+			return { content: [{ type: 'text', text: lines.join('\n\n') }] };
+		},
+	);
+
+	server.tool(
+		'windows_display_set',
+		'Change display settings: resolution, brightness.',
+		{
+			resolution: z.string().optional().describe('Resolution as "WIDTHxHEIGHT" (e.g. "1920x1080")'),
+			brightness: z.number().min(0).max(100).optional().describe('Screen brightness 0-100 (laptops only)'),
+		},
+		async ({ resolution, brightness }) => {
+			const results: string[] = [];
+
+			if (brightness !== undefined) {
+				const ps = `
+try {
+  $monitors = Get-CimInstance -Namespace root/WMI -ClassName WmiMonitorBrightnessMethods -ErrorAction Stop
+  $monitors | Invoke-CimMethod -MethodName WmiSetBrightness -Arguments @{Timeout=1; Brightness=${brightness}} -ErrorAction Stop
+  "Brightness set to ${brightness}%"
+} catch {
+  "Error: Brightness control not available (requires laptop/integrated display). $_"
+}`;
+				const r = await runPowerShell(ps);
+				results.push(r.stdout || r.stderr);
+			}
+
+			if (resolution) {
+				const match = resolution.match(/^(\d+)x(\d+)$/);
+				if (!match) {
+					results.push('Invalid resolution format. Use WIDTHxHEIGHT (e.g. 1920x1080)');
+				} else {
+					const ps = `
+Add-Type @'
+using System;
+using System.Runtime.InteropServices;
+
+public class DisplaySettings {
+    [DllImport("user32.dll")]
+    public static extern int EnumDisplaySettings(string deviceName, int modeNum, ref DEVMODE devMode);
+    [DllImport("user32.dll")]
+    public static extern int ChangeDisplaySettings(ref DEVMODE devMode, int flags);
+
+    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
+    public struct DEVMODE {
+        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
+        public string dmDeviceName;
+        public short dmSpecVersion;
+        public short dmDriverVersion;
+        public short dmSize;
+        public short dmDriverExtra;
+        public int dmFields;
+        public int dmPositionX;
+        public int dmPositionY;
+        public int dmDisplayOrientation;
+        public int dmDisplayFixedOutput;
+        public short dmColor;
+        public short dmDuplex;
+        public short dmYResolution;
+        public short dmTTOption;
+        public short dmCollate;
+        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
+        public string dmFormName;
+        public short dmLogPixels;
+        public int dmBitsPerPel;
+        public int dmPelsWidth;
+        public int dmPelsHeight;
+        public int dmDisplayFlags;
+        public int dmDisplayFrequency;
+    }
+
+    public static string SetResolution(int width, int height) {
+        DEVMODE dm = new DEVMODE();
+        dm.dmSize = (short)Marshal.SizeOf(typeof(DEVMODE));
+        if (EnumDisplaySettings(null, -1, ref dm) != 0) {
+            dm.dmPelsWidth = width;
+            dm.dmPelsHeight = height;
+            dm.dmFields = 0x80000 | 0x100000; // DM_PELSWIDTH | DM_PELSHEIGHT
+            int result = ChangeDisplaySettings(ref dm, 0);
+            if (result == 0) return "Resolution changed to " + width + "x" + height;
+            return "Failed to change resolution (code: " + result + "). Resolution may not be supported.";
+        }
+        return "Failed to enumerate display settings.";
+    }
+}
+'@ -ErrorAction Stop
+[DisplaySettings]::SetResolution(${match[1]}, ${match[2]})`;
+					const r = await runPowerShell(ps);
+					results.push(r.stdout || r.stderr);
+				}
+			}
+
+			if (results.length === 0) {
+				return { content: [{ type: 'text', text: 'No changes specified. Provide resolution or brightness.' }], isError: true };
+			}
+
+			return { content: [{ type: 'text', text: results.join('\n') }] };
+		},
+	);
+
+	server.tool(
+		'windows_screenshot',
+		'Capture a screenshot of the screen, a specific window, or a region. Returns as base64 image.',
+		{
+			target: z.enum(['screen', 'window', 'region']).default('screen').describe('What to capture'),
+			monitor: z.number().default(0).describe('Monitor index (for screen capture)'),
+			window_title: z.string().optional().describe('Window title substring (for window capture)'),
+			x: z.number().optional().describe('Region X (for region capture)'),
+			y: z.number().optional().describe('Region Y'),
+			width: z.number().optional().describe('Region width'),
+			height: z.number().optional().describe('Region height'),
+			save_path: z.string().optional().describe('Save to file instead of returning base64'),
+		},
+		async ({ target, monitor, window_title, x, y, width, height, save_path }) => {
+			const outPath = save_path ? resolve(save_path) : resolve(tmpdir(), `screenshot_${Date.now()}.png`);
+
+			let ps: string;
+
+			if (target === 'window' && window_title) {
+				ps = `
+Add-Type -AssemblyName System.Windows.Forms
+Add-Type -AssemblyName System.Drawing
+Add-Type @'
+using System;
+using System.Runtime.InteropServices;
+public class Win32Window {
+    [DllImport("user32.dll")] public static extern IntPtr FindWindow(string lpClassName, string lpWindowName);
+    [DllImport("user32.dll")] public static extern bool GetWindowRect(IntPtr hWnd, out RECT lpRect);
+    [DllImport("user32.dll")] public static extern IntPtr GetForegroundWindow();
+    [DllImport("user32.dll")] public static extern bool SetForegroundWindow(IntPtr hWnd);
+    [DllImport("user32.dll", CharSet = CharSet.Auto)] public static extern int GetWindowText(IntPtr hWnd, System.Text.StringBuilder text, int count);
+    [DllImport("user32.dll")] public static extern bool EnumWindows(EnumWindowsProc lpEnumFunc, IntPtr lParam);
+    public delegate bool EnumWindowsProc(IntPtr hWnd, IntPtr lParam);
+    [StructLayout(LayoutKind.Sequential)]
+    public struct RECT { public int Left, Top, Right, Bottom; }
+}
+'@
+$target = '${window_title.replace(/'/g, "''")}'
+$found = $null
+[Win32Window]::EnumWindows({
+  param($hWnd, $lParam)
+  $sb = New-Object System.Text.StringBuilder 256
+  [Win32Window]::GetWindowText($hWnd, $sb, 256) | Out-Null
+  $title = $sb.ToString()
+  if ($title -like "*$target*") { $script:found = $hWnd; return $false }
+  return $true
+}, [IntPtr]::Zero) | Out-Null
+
+if (-not $found) { throw "Window not found: $target" }
+
+$rect = New-Object Win32Window+RECT
+[Win32Window]::GetWindowRect($found, [ref]$rect) | Out-Null
+$w = $rect.Right - $rect.Left
+$h = $rect.Bottom - $rect.Top
+$bmp = New-Object System.Drawing.Bitmap($w, $h)
+$g = [System.Drawing.Graphics]::FromImage($bmp)
+$g.CopyFromScreen($rect.Left, $rect.Top, 0, 0, [System.Drawing.Size]::new($w, $h))
+$g.Dispose()
+$bmp.Save('${outPath.replace(/'/g, "''")}', [System.Drawing.Imaging.ImageFormat]::Png)
+$bmp.Dispose()
+"saved"`;
+			} else if (target === 'region' && x !== undefined && y !== undefined && width && height) {
+				ps = `
+Add-Type -AssemblyName System.Drawing
+$bmp = New-Object System.Drawing.Bitmap(${width}, ${height})
+$g = [System.Drawing.Graphics]::FromImage($bmp)
+$g.CopyFromScreen(${x}, ${y}, 0, 0, [System.Drawing.Size]::new(${width}, ${height}))
+$g.Dispose()
+$bmp.Save('${outPath.replace(/'/g, "''")}', [System.Drawing.Imaging.ImageFormat]::Png)
+$bmp.Dispose()
+"saved"`;
+			} else {
+				// Full screen
+				ps = `
+Add-Type -AssemblyName System.Windows.Forms
+Add-Type -AssemblyName System.Drawing
+$screen = [System.Windows.Forms.Screen]::AllScreens[${monitor}]
+$bounds = $screen.Bounds
+$bmp = New-Object System.Drawing.Bitmap($bounds.Width, $bounds.Height)
+$g = [System.Drawing.Graphics]::FromImage($bmp)
+$g.CopyFromScreen($bounds.X, $bounds.Y, 0, 0, $bounds.Size)
+$g.Dispose()
+$bmp.Save('${outPath.replace(/'/g, "''")}', [System.Drawing.Imaging.ImageFormat]::Png)
+$bmp.Dispose()
+"saved"`;
+			}
+
+			const result = await runPowerShell(ps, { timeout: 10000 });
+			if (result.exitCode !== 0) {
+				return { content: [{ type: 'text', text: `Error: ${result.stderr}` }], isError: true };
+			}
+
+			if (save_path) {
+				return { content: [{ type: 'text', text: `Screenshot saved: ${outPath}` }] };
+			}
+
+			// Return as base64 image
+			try {
+				const data = await readFile(outPath);
+				// Clean up temp file
+				await import('node:fs/promises').then(fs => fs.unlink(outPath)).catch(() => {});
+				return {
+					content: [{
+						type: 'image' as const,
+						data: data.toString('base64'),
+						mimeType: 'image/png',
+					}],
+				};
+			} catch {
+				return { content: [{ type: 'text', text: `Screenshot captured at ${outPath} but failed to read back.` }] };
+			}
+		},
+	);
+}