@mokoconsulting/mcp-windows 3.0.0

package/dist/tools/automation.js

@@ -0,0 +1,261 @@
+/* Copyright (C) 2026 Moko Consulting <hello@mokoconsulting.tech>
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ * Tools: windows_shortcut (#78), windows_input (#79),
+ *        windows_font_list (#80), windows_sandbox (#81), windows_screen_capture (#82)
+ */
+import { z } from 'zod';
+import { runPowerShell } from '../shell.js';
+export function registerAutomationTools(server) {
+    server.tool('windows_shortcut', 'Create, read, or modify Windows shortcut (.lnk) files.', {
+        action: z.enum(['create', 'read']).describe('Action'),
+        path: z.string().describe('Shortcut .lnk file path'),
+        target: z.string().optional().describe('Target path (for create)'),
+        arguments: z.string().optional().describe('Arguments (for create)'),
+        icon: z.string().optional().describe('Icon path (for create)'),
+        working_dir: z.string().optional().describe('Working directory (for create)'),
+        description: z.string().optional().describe('Description (for create)'),
+    }, async ({ action, path, target, arguments: args, icon, working_dir, description }) => {
+        if (action === 'read') {
+            const ps = `
+$ws = New-Object -ComObject WScript.Shell
+$sc = $ws.CreateShortcut('${path.replace(/'/g, "''")}')
+[PSCustomObject]@{
+  Target = $sc.TargetPath
+  Arguments = $sc.Arguments
+  WorkingDir = $sc.WorkingDirectory
+  Icon = $sc.IconLocation
+  Description = $sc.Description
+  Hotkey = $sc.Hotkey
+  WindowStyle = $sc.WindowStyle
+} | ConvertTo-Json -Compress`;
+            const result = await runPowerShell(ps, { timeout: 10000 });
+            if (result.exitCode !== 0)
+                return { content: [{ type: 'text', text: `Error: ${result.stderr}` }], isError: true };
+            const sc = JSON.parse(result.stdout);
+            return {
+                content: [{
+                        type: 'text',
+                        text: `${path}\n  Target: ${sc.Target}\n  Args: ${sc.Arguments || '(none)'}\n  Dir: ${sc.WorkingDir || '(none)'}\n  Icon: ${sc.Icon || '(default)'}\n  Description: ${sc.Description || '(none)'}`,
+                    }],
+            };
+        }
+        if (!target)
+            return { content: [{ type: 'text', text: 'create requires target.' }], isError: true };
+        const ps = `
+$ws = New-Object -ComObject WScript.Shell
+$sc = $ws.CreateShortcut('${path.replace(/'/g, "''")}')
+$sc.TargetPath = '${target.replace(/'/g, "''")}'
+${args ? `$sc.Arguments = '${args.replace(/'/g, "''")}'` : ''}
+${working_dir ? `$sc.WorkingDirectory = '${working_dir.replace(/'/g, "''")}'` : ''}
+${icon ? `$sc.IconLocation = '${icon.replace(/'/g, "''")}'` : ''}
+${description ? `$sc.Description = '${description.replace(/'/g, "''")}'` : ''}
+$sc.Save()
+"Shortcut created: ${path}"`;
+        const result = await runPowerShell(ps, { timeout: 10000 });
+        return { content: [{ type: 'text', text: result.stdout || result.stderr }], isError: result.exitCode !== 0 };
+    });
+    server.tool('windows_input', 'Simulate keyboard presses, key combos, or type text. Also simulate mouse clicks and movement.', {
+        type: z.enum(['key', 'combo', 'text', 'mouse_click', 'mouse_move']).describe('Input type'),
+        key: z.string().optional().describe('Key name for key/combo (e.g. "Enter", "Ctrl+C", "Alt+F4")'),
+        text: z.string().optional().describe('Text to type (for text type)'),
+        x: z.number().optional().describe('Mouse X coordinate'),
+        y: z.number().optional().describe('Mouse Y coordinate'),
+        button: z.enum(['left', 'right', 'middle']).default('left').describe('Mouse button'),
+        delay: z.number().default(50).describe('Delay between actions in ms'),
+    }, async ({ type, key, text, x, y, button, delay }) => {
+        let ps;
+        switch (type) {
+            case 'key':
+                if (!key)
+                    return { content: [{ type: 'text', text: 'key requires key name.' }], isError: true };
+                ps = `
+Add-Type -AssemblyName System.Windows.Forms
+[System.Windows.Forms.SendKeys]::SendWait('{${key.toUpperCase()}}')
+"Sent key: ${key}"`;
+                break;
+            case 'combo':
+                if (!key)
+                    return { content: [{ type: 'text', text: 'combo requires key.' }], isError: true };
+                // Map Ctrl+C style to SendKeys format: ^c
+                const mapped = key
+                    .replace(/Ctrl\+/gi, '^')
+                    .replace(/Alt\+/gi, '%')
+                    .replace(/Shift\+/gi, '+')
+                    .replace(/Win\+/gi, '^{ESC}'); // approximate
+                ps = `
+Add-Type -AssemblyName System.Windows.Forms
+[System.Windows.Forms.SendKeys]::SendWait('${mapped}')
+"Sent combo: ${key}"`;
+                break;
+            case 'text':
+                if (!text)
+                    return { content: [{ type: 'text', text: 'text requires text.' }], isError: true };
+                // Escape SendKeys special chars
+                const escaped = text.replace(/[+^%~(){}[\]]/g, '{$&}');
+                ps = `
+Add-Type -AssemblyName System.Windows.Forms
+[System.Windows.Forms.SendKeys]::SendWait('${escaped.replace(/'/g, "''")}')
+"Typed ${text.length} characters"`;
+                break;
+            case 'mouse_click':
+                if (x === undefined || y === undefined)
+                    return { content: [{ type: 'text', text: 'mouse_click requires x and y.' }], isError: true };
+                const btnFlag = button === 'right' ? '0x0008,0x0010' : button === 'middle' ? '0x0020,0x0040' : '0x0002,0x0004';
+                ps = `
+Add-Type @'
+using System.Runtime.InteropServices;
+public class MouseInput {
+    [DllImport("user32.dll")] public static extern bool SetCursorPos(int X, int Y);
+    [DllImport("user32.dll")] public static extern void mouse_event(uint dwFlags, int dx, int dy, uint dwData, int dwExtraInfo);
+}
+'@
+[MouseInput]::SetCursorPos(${x}, ${y})
+Start-Sleep -Milliseconds ${delay}
+[MouseInput]::mouse_event(${btnFlag.split(',')[0]}, 0, 0, 0, 0)
+[MouseInput]::mouse_event(${btnFlag.split(',')[1]}, 0, 0, 0, 0)
+"Clicked ${button} at (${x}, ${y})"`;
+                break;
+            case 'mouse_move':
+                if (x === undefined || y === undefined)
+                    return { content: [{ type: 'text', text: 'mouse_move requires x and y.' }], isError: true };
+                ps = `
+Add-Type @'
+using System.Runtime.InteropServices;
+public class MouseMove { [DllImport("user32.dll")] public static extern bool SetCursorPos(int X, int Y); }
+'@
+[MouseMove]::SetCursorPos(${x}, ${y})
+"Moved mouse to (${x}, ${y})"`;
+                break;
+        }
+        const result = await runPowerShell(ps, { timeout: 10000 });
+        return { content: [{ type: 'text', text: result.stdout || result.stderr }], isError: result.exitCode !== 0 };
+    });
+    server.tool('windows_font_list', 'List installed system and user fonts.', {
+        filter: z.string().optional().describe('Filter by font name'),
+    }, async ({ filter }) => {
+        const filterClause = filter ? `| Where-Object { $_.Name -like '*${filter.replace(/'/g, "''")}*' }` : '';
+        const ps = `
+Get-ItemProperty 'HKLM:\\SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Fonts' |
+  ForEach-Object { $_.PSObject.Properties } |
+  Where-Object { $_.Name -notlike 'PS*' } |
+  ForEach-Object { [PSCustomObject]@{ Name = $_.Name; File = $_.Value } } ${filterClause} |
+  Sort-Object Name |
+  ConvertTo-Json -Depth 3 -Compress`;
+        const result = await runPowerShell(ps, { timeout: 15000 });
+        if (result.exitCode !== 0)
+            return { content: [{ type: 'text', text: `Error: ${result.stderr}` }], isError: true };
+        if (!result.stdout)
+            return { content: [{ type: 'text', text: 'No fonts found.' }] };
+        const fonts = Array.isArray(JSON.parse(result.stdout)) ? JSON.parse(result.stdout) : [JSON.parse(result.stdout)];
+        const lines = fonts.map((f) => `  ${f.Name}`);
+        return { content: [{ type: 'text', text: `Installed fonts (${fonts.length}):\n${lines.join('\n')}` }] };
+    });
+    server.tool('windows_sandbox', 'Check Windows Sandbox status, launch with default or custom config.', {
+        action: z.enum(['status', 'launch', 'generate_config']).default('status').describe('Action'),
+        mapped_folder: z.string().optional().describe('Host folder to map into sandbox'),
+        read_only: z.boolean().default(true).describe('Map folder as read-only'),
+        networking: z.boolean().default(true).describe('Enable networking in sandbox'),
+        startup_command: z.string().optional().describe('Command to run on sandbox startup'),
+        config_path: z.string().optional().describe('Path to save/load .wsb config'),
+    }, async ({ action, mapped_folder, read_only, networking, startup_command, config_path }) => {
+        if (action === 'status') {
+            const ps = `
+$feature = Get-WindowsOptionalFeature -Online -FeatureName 'Containers-DisposableClientVM' -ErrorAction SilentlyContinue
+if ($feature) {
+  "Windows Sandbox: $($feature.State)"
+} else {
+  "Windows Sandbox feature not found"
+}`;
+            const result = await runPowerShell(ps, { timeout: 15000 });
+            return { content: [{ type: 'text', text: result.stdout || result.stderr }] };
+        }
+        if (action === 'generate_config' || action === 'launch') {
+            const wsbLines = ['<Configuration>'];
+            if (!networking)
+                wsbLines.push('  <Networking>Disable</Networking>');
+            if (mapped_folder) {
+                wsbLines.push('  <MappedFolders>');
+                wsbLines.push('    <MappedFolder>');
+                wsbLines.push(`      <HostFolder>${mapped_folder}</HostFolder>`);
+                wsbLines.push(`      <ReadOnly>${read_only ? 'true' : 'false'}</ReadOnly>`);
+                wsbLines.push('    </MappedFolder>');
+                wsbLines.push('  </MappedFolders>');
+            }
+            if (startup_command) {
+                wsbLines.push(`  <LogonCommand><Command>${startup_command}</Command></LogonCommand>`);
+            }
+            wsbLines.push('</Configuration>');
+            const wsb = wsbLines.join('\n');
+            if (action === 'generate_config') {
+                if (config_path) {
+                    const ps = `Set-Content -Path '${config_path.replace(/'/g, "''")}' -Value @'\n${wsb}\n'@\n"Config saved: ${config_path}"`;
+                    const result = await runPowerShell(ps, { timeout: 5000 });
+                    return { content: [{ type: 'text', text: result.stdout || result.stderr }] };
+                }
+                return { content: [{ type: 'text', text: wsb }] };
+            }
+            // Launch
+            const tempWsb = config_path || `$env:TEMP\\mcp_sandbox_${Date.now()}.wsb`;
+            const ps = `
+Set-Content -Path '${tempWsb}' -Value @'
+${wsb}
+'@
+Start-Process '${tempWsb}'
+"Sandbox launched${config_path ? '' : ' (temp config)'}"`;
+            const result = await runPowerShell(ps, { timeout: 10000 });
+            return { content: [{ type: 'text', text: result.stdout || result.stderr }] };
+        }
+        return { content: [{ type: 'text', text: 'Unknown action.' }], isError: true };
+    });
+    server.tool('windows_screen_capture', 'Start or stop screen recording. Uses ffmpeg if available, otherwise reports status only.', {
+        action: z.enum(['start', 'stop', 'status']).describe('Action'),
+        output: z.string().optional().describe('Output file path (for start)'),
+        fps: z.number().default(15).describe('Framerate'),
+    }, async ({ action, output, fps }) => {
+        if (action === 'status') {
+            const ps = `
+$ffmpeg = Get-Command ffmpeg -ErrorAction SilentlyContinue
+$recording = Get-Process ffmpeg -ErrorAction SilentlyContinue | Where-Object { $_.CommandLine -like '*gdigrab*' }
+[PSCustomObject]@{
+  FfmpegInstalled = $null -ne $ffmpeg
+  FfmpegPath = if ($ffmpeg) { $ffmpeg.Source } else { $null }
+  ActiveRecording = $null -ne $recording
+  RecordingPID = if ($recording) { $recording.Id } else { $null }
+} | ConvertTo-Json -Compress`;
+            const result = await runPowerShell(ps, { timeout: 10000 });
+            if (result.exitCode !== 0)
+                return { content: [{ type: 'text', text: `Error: ${result.stderr}` }], isError: true };
+            const info = JSON.parse(result.stdout);
+            return {
+                content: [{
+                        type: 'text',
+                        text: `ffmpeg: ${info.FfmpegInstalled ? info.FfmpegPath : 'Not installed (install via winget: winget install Gyan.FFmpeg)'}\nRecording: ${info.ActiveRecording ? `Active (PID ${info.RecordingPID})` : 'None'}`,
+                    }],
+            };
+        }
+        if (action === 'start') {
+            const outPath = output || `A:/temp/recording_${Date.now()}.mp4`;
+            const ps = `
+$ffmpeg = Get-Command ffmpeg -ErrorAction SilentlyContinue
+if (-not $ffmpeg) { throw "ffmpeg not installed. Install with: winget install Gyan.FFmpeg" }
+Start-Process ffmpeg -ArgumentList '-f gdigrab -framerate ${fps} -i desktop -c:v libx264 -preset ultrafast "${outPath}"' -WindowStyle Hidden -PassThru | ForEach-Object { "Recording started (PID $($_.Id)). Output: ${outPath}" }`;
+            const result = await runPowerShell(ps, { timeout: 10000 });
+            return { content: [{ type: 'text', text: result.stdout || result.stderr }], isError: result.exitCode !== 0 };
+        }
+        if (action === 'stop') {
+            const ps = `
+$procs = Get-Process ffmpeg -ErrorAction SilentlyContinue | Where-Object { $_.CommandLine -like '*gdigrab*' -or $_.CommandLine -eq $null }
+if ($procs) {
+  $procs | ForEach-Object { $_.CloseMainWindow() | Out-Null }
+  Start-Sleep -Seconds 2
+  $procs | Stop-Process -Force -ErrorAction SilentlyContinue
+  "Recording stopped ($(@($procs).Count) process(es))"
+} else { "No active recording found" }`;
+            const result = await runPowerShell(ps, { timeout: 10000 });
+            return { content: [{ type: 'text', text: result.stdout || result.stderr }] };
+        }
+        return { content: [{ type: 'text', text: 'Unknown action.' }], isError: true };
+    });
+}
+//# sourceMappingURL=automation.js.map

package/dist/tools/bluetooth.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerBluetoothTools(server: McpServer): void;
+//# sourceMappingURL=bluetooth.d.ts.map

package/dist/tools/bluetooth.js

@@ -0,0 +1,96 @@
+/* Copyright (C) 2026 Moko Consulting <hello@mokoconsulting.tech>
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ * Tools: windows_bluetooth_get (#45), windows_bluetooth_control (#46)
+ */
+import { z } from 'zod';
+import { runPowerShell } from '../shell.js';
+export function registerBluetoothTools(server) {
+    server.tool('windows_bluetooth_get', 'Get Bluetooth adapter status and list paired/connected devices.', {}, async () => {
+        const ps = `
+$adapter = Get-PnpDevice -Class Bluetooth -ErrorAction SilentlyContinue | Where-Object { $_.FriendlyName -match 'Bluetooth' -and $_.Class -eq 'Bluetooth' } | Select-Object -First 1
+$enabled = if ($adapter) { $adapter.Status -eq 'OK' } else { $false }
+
+$devices = Get-PnpDevice -Class Bluetooth -ErrorAction SilentlyContinue |
+  Where-Object { $_.FriendlyName -and $_.Class -eq 'Bluetooth' -and $_.FriendlyName -notmatch 'Bluetooth|Radio|Enumerator' } |
+  ForEach-Object {
+    [PSCustomObject]@{
+      Name = $_.FriendlyName
+      Status = $_.Status
+      InstanceId = $_.InstanceId
+      Connected = $_.Status -eq 'OK'
+    }
+  }
+
+[PSCustomObject]@{
+  AdapterPresent = $null -ne $adapter
+  AdapterName = if ($adapter) { $adapter.FriendlyName } else { 'None' }
+  Enabled = $enabled
+  Devices = $devices
+} | ConvertTo-Json -Depth 4 -Compress`;
+        const result = await runPowerShell(ps, { timeout: 15000 });
+        if (result.exitCode !== 0) {
+            return { content: [{ type: 'text', text: `Error: ${result.stderr}` }], isError: true };
+        }
+        const info = JSON.parse(result.stdout);
+        const lines = [
+            `Bluetooth: ${info.AdapterPresent ? (info.Enabled ? 'ON' : 'OFF') : 'Not available'}`,
+            `Adapter: ${info.AdapterName}`,
+        ];
+        const devices = Array.isArray(info.Devices) ? info.Devices : info.Devices ? [info.Devices] : [];
+        if (devices.length > 0) {
+            lines.push('', 'Paired Devices:');
+            for (const d of devices) {
+                const icon = d.Connected ? '[CON]' : '[   ]';
+                lines.push(`  ${icon} ${d.Name}`);
+            }
+        }
+        else {
+            lines.push('', 'No paired devices.');
+        }
+        return { content: [{ type: 'text', text: lines.join('\n') }] };
+    });
+    server.tool('windows_bluetooth_control', 'Enable/disable Bluetooth adapter or disconnect a device.', {
+        action: z.enum(['enable', 'disable', 'disconnect']).describe('Action'),
+        device: z.string().optional().describe('Device name (for disconnect)'),
+    }, async ({ action, device }) => {
+        let ps;
+        switch (action) {
+            case 'enable':
+                ps = `
+$adapter = Get-PnpDevice -Class Bluetooth -ErrorAction Stop | Where-Object { $_.FriendlyName -match 'Bluetooth' -and $_.Class -eq 'Bluetooth' } | Select-Object -First 1
+if ($adapter) {
+  Enable-PnpDevice -InstanceId $adapter.InstanceId -Confirm:$false -ErrorAction Stop
+  "Bluetooth enabled"
+} else { "No Bluetooth adapter found" }`;
+                break;
+            case 'disable':
+                ps = `
+$adapter = Get-PnpDevice -Class Bluetooth -ErrorAction Stop | Where-Object { $_.FriendlyName -match 'Bluetooth' -and $_.Class -eq 'Bluetooth' } | Select-Object -First 1
+if ($adapter) {
+  Disable-PnpDevice -InstanceId $adapter.InstanceId -Confirm:$false -ErrorAction Stop
+  "Bluetooth disabled"
+} else { "No Bluetooth adapter found" }`;
+                break;
+            case 'disconnect':
+                if (!device) {
+                    return { content: [{ type: 'text', text: 'Disconnect requires device name.' }], isError: true };
+                }
+                ps = `
+$dev = Get-PnpDevice -Class Bluetooth -ErrorAction SilentlyContinue | Where-Object { $_.FriendlyName -like '*${device.replace(/'/g, "''")}*' } | Select-Object -First 1
+if ($dev) {
+  Disable-PnpDevice -InstanceId $dev.InstanceId -Confirm:$false -ErrorAction Stop
+  Start-Sleep -Seconds 1
+  Enable-PnpDevice -InstanceId $dev.InstanceId -Confirm:$false -ErrorAction Stop
+  "Disconnected and re-enabled: $($dev.FriendlyName)"
+} else { "Device not found: ${device}" }`;
+                break;
+        }
+        const result = await runPowerShell(ps, { timeout: 15000 });
+        return {
+            content: [{ type: 'text', text: result.stdout || result.stderr }],
+            isError: result.exitCode !== 0,
+        };
+    });
+}
+//# sourceMappingURL=bluetooth.js.map

package/dist/tools/clipboard.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerClipboardTools(server: McpServer): void;
+//# sourceMappingURL=clipboard.d.ts.map

package/dist/tools/clipboard.js

@@ -0,0 +1,118 @@
+/* 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 { z } from 'zod';
+import { runPowerShell } from '../shell.js';
+export function registerClipboardTools(server) {
+    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', text: 'Clipboard contains an image:' },
+                        { type: 'image', 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 };
+    });
+}
+//# sourceMappingURL=clipboard.js.map

package/dist/tools/config.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerConfigTools(server: McpServer): void;
+//# sourceMappingURL=config.d.ts.map

package/dist/tools/config.js

@@ -0,0 +1,85 @@
+/* Copyright (C) 2026 Moko Consulting <hello@mokoconsulting.tech>
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ * Tool: windows_mcp_config (#40)
+ */
+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');
+const DEFAULT_CONFIG = {
+    blockedCommands: ['Format-Volume', 'Clear-Disk', 'Remove-Partition'],
+    allowedDirectories: [],
+    outputLineLimit: 5000,
+    commandTimeout: 30000,
+};
+let currentConfig = null;
+async function loadConfig() {
+    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) {
+    await writeFile(CONFIG_PATH, JSON.stringify(config, null, 2), 'utf-8');
+    currentConfig = config;
+}
+export function registerConfigTools(server) {
+    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[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[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}` }] };
+    });
+}
+//# sourceMappingURL=config.js.map

package/dist/tools/dialog.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerDialogTools(server: McpServer): void;
+//# sourceMappingURL=dialog.d.ts.map

package/dist/tools/dialog.js

@@ -0,0 +1,72 @@
+/* Copyright (C) 2026 Moko Consulting <hello@mokoconsulting.tech>
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ * Tool: windows_dialog (#21)
+ */
+import { z } from 'zod';
+import { runPowerShell } from '../shell.js';
+export function registerDialogTools(server) {
+    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;
+        switch (type) {
+            case 'message': {
+                const btnMap = { 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 }] };
+    });
+}
+//# sourceMappingURL=dialog.js.map

package/dist/tools/display.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerDisplayTools(server: McpServer): void;
+//# sourceMappingURL=display.d.ts.map