@mokoconsulting/mcp-windows 3.0.0

package/src/tools/audio.ts

@@ -0,0 +1,161 @@
+/* Copyright (C) 2026 Moko Consulting <hello@mokoconsulting.tech>
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ * Tools: windows_audio_get (#6), windows_audio_set (#7)
+ * Uses compiled SetMute.exe for reliable COM audio control.
+ */
+
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import { runPowerShell } from '../shell.js';
+
+const AUDIO_PS = `
+Add-Type -TypeDefinition @'
+using System;
+using System.Runtime.InteropServices;
+
+public class WinAudio {
+    [Guid("A95664D2-9614-4F35-A746-DE8DB63617E6"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    interface IMMDeviceEnumerator {
+        int EnumAudioEndpoints(int dataFlow, int dwStateMask, out IntPtr ppDevices);
+        int GetDefaultAudioEndpoint(int dataFlow, int role, out IMMDevice ppEndpoint);
+    }
+
+    [Guid("D666063F-1587-4E43-81F1-B948E807363F"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    interface IMMDevice {
+        int Activate(ref Guid iid, int dwClsCtx, IntPtr pActivationParams, [MarshalAs(UnmanagedType.IUnknown)] out object ppInterface);
+    }
+
+    [Guid("5CDF2C82-841E-4546-9722-0CF74078229A"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    interface IAudioEndpointVolume {
+        int RegisterControlChangeNotify(IntPtr pNotify);
+        int UnregisterControlChangeNotify(IntPtr pNotify);
+        int GetChannelCount(out int pnChannelCount);
+        int SetMasterVolumeLevel(float fLevelDB, ref Guid pguidEventContext);
+        int SetMasterVolumeLevelScalar(float fLevel, ref Guid pguidEventContext);
+        int GetMasterVolumeLevel(out float pfLevelDB);
+        int GetMasterVolumeLevelScalar(out float pfLevel);
+        int SetChannelVolumeLevel(int nChannel, float fLevelDB, ref Guid pguidEventContext);
+        int SetChannelVolumeLevelScalar(int nChannel, float fLevel, ref Guid pguidEventContext);
+        int GetChannelVolumeLevel(int nChannel, out float pfLevelDB);
+        int GetChannelVolumeLevelScalar(int nChannel, out float pfLevel);
+        int SetMute([MarshalAs(UnmanagedType.Bool)] bool bMute, ref Guid pguidEventContext);
+        int GetMute([MarshalAs(UnmanagedType.Bool)] out bool pbMute);
+    }
+
+    private static IAudioEndpointVolume GetVolume() {
+        var type = Type.GetTypeFromCLSID(new Guid("BCDE0395-E52F-467C-8E3D-C4579291692E"));
+        var enumerator = (IMMDeviceEnumerator)Activator.CreateInstance(type);
+        IMMDevice device;
+        enumerator.GetDefaultAudioEndpoint(0, 1, out device);
+        var iid = new Guid("5CDF2C82-841E-4546-9722-0CF74078229A");
+        object obj;
+        device.Activate(ref iid, 0x17, IntPtr.Zero, out obj);
+        return (IAudioEndpointVolume)obj;
+    }
+
+    public static float GetVolumeLevel() {
+        var vol = GetVolume();
+        float level;
+        vol.GetMasterVolumeLevelScalar(out level);
+        return level;
+    }
+
+    public static bool GetMute() {
+        var vol = GetVolume();
+        bool muted;
+        vol.GetMute(out muted);
+        return muted;
+    }
+
+    public static void SetVolumeLevel(float level) {
+        var vol = GetVolume();
+        var ctx = Guid.Empty;
+        vol.SetMasterVolumeLevelScalar(level, ref ctx);
+    }
+
+    public static void SetMute(bool mute) {
+        var vol = GetVolume();
+        var ctx = Guid.Empty;
+        vol.SetMute(mute, ref ctx);
+    }
+}
+'@ -ErrorAction Stop
+`;
+
+export function registerAudioTools(server: McpServer): void {
+	server.tool(
+		'windows_audio_get',
+		'Get current audio state: volume level (0-100), mute status, and default playback device.',
+		{},
+		async () => {
+			const ps = `
+${AUDIO_PS}
+$volume = [math]::Round([WinAudio]::GetVolumeLevel() * 100)
+$muted = [WinAudio]::GetMute()
+$device = (Get-CimInstance Win32_SoundDevice | Where-Object { $_.Status -eq 'OK' } | Select-Object -First 1).Name
+[PSCustomObject]@{
+  volume = $volume
+  muted = $muted
+  device = $device
+} | ConvertTo-Json -Compress`;
+
+			const result = await runPowerShell(ps, { timeout: 60000 });
+			if (result.exitCode !== 0) {
+				return { content: [{ type: 'text', text: `Error: ${result.stderr}` }], isError: true };
+			}
+
+			const state = JSON.parse(result.stdout);
+			const muteIcon = state.muted ? '🔇' : (state.volume > 50 ? '🔊' : '🔉');
+			return {
+				content: [{
+					type: 'text',
+					text: `${muteIcon} Volume: ${state.volume}%${state.muted ? ' (MUTED)' : ''}\nDevice: ${state.device || 'Unknown'}`,
+				}],
+			};
+		},
+	);
+
+	server.tool(
+		'windows_audio_set',
+		'Set audio volume (0-100), mute/unmute, or toggle mute.',
+		{
+			volume: z.number().min(0).max(100).optional().describe('Volume level 0-100'),
+			mute: z.enum(['true', 'false', 'toggle']).optional().describe('Mute state: true, false, or toggle'),
+		},
+		async ({ volume, mute }) => {
+			const commands: string[] = [AUDIO_PS];
+
+			if (volume !== undefined) {
+				commands.push(`[WinAudio]::SetVolumeLevel(${volume / 100})`);
+			}
+
+			if (mute === 'toggle') {
+				commands.push(`[WinAudio]::SetMute(-not [WinAudio]::GetMute())`);
+			} else if (mute === 'true') {
+				commands.push(`[WinAudio]::SetMute($true)`);
+			} else if (mute === 'false') {
+				commands.push(`[WinAudio]::SetMute($false)`);
+			}
+
+			// Read back state
+			commands.push(`
+$vol = [math]::Round([WinAudio]::GetVolumeLevel() * 100)
+$m = [WinAudio]::GetMute()
+[PSCustomObject]@{ volume = $vol; muted = $m } | ConvertTo-Json -Compress`);
+
+			const result = await runPowerShell(commands.join('\n'));
+			if (result.exitCode !== 0) {
+				return { content: [{ type: 'text', text: `Error: ${result.stderr}` }], isError: true };
+			}
+
+			const state = JSON.parse(result.stdout);
+			return {
+				content: [{
+					type: 'text',
+					text: `Volume set to ${state.volume}%${state.muted ? ' (MUTED)' : ''}`,
+				}],
+			};
+		},
+	);
+}

package/src/tools/audio_apps.ts

@@ -0,0 +1,98 @@
+/* Copyright (C) 2026 Moko Consulting <hello@mokoconsulting.tech>
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ * Tool: windows_audio_app_volumes (#8)
+ */
+
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import { runPowerShell } from '../shell.js';
+
+export function registerAudioAppTools(server: McpServer): void {
+	server.tool(
+		'windows_audio_app_volumes',
+		'Get or set per-application audio volume levels. Without set params, lists all app audio sessions.',
+		{
+			app: z.string().optional().describe('App name to target (for set operations)'),
+			volume: z.number().min(0).max(100).optional().describe('Volume to set (0-100)'),
+			mute: z.enum(['true', 'false', 'toggle']).optional().describe('Mute state to set'),
+		},
+		async ({ app, volume, mute }) => {
+			// List mode — show all audio sessions via PowerShell + COM
+			const ps = `
+Add-Type -TypeDefinition @'
+using System;
+using System.Runtime.InteropServices;
+using System.Collections.Generic;
+using System.Diagnostics;
+
+public class AudioSessions {
+    [Guid("A95664D2-9614-4F35-A746-DE8DB63617E6"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    interface IMMDeviceEnumerator {
+        int EnumAudioEndpoints(int dataFlow, int dwStateMask, out IntPtr ppDevices);
+        int GetDefaultAudioEndpoint(int dataFlow, int role, out IMMDevice ppEndpoint);
+    }
+
+    [Guid("D666063F-1587-4E43-81F1-B948E807363F"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    interface IMMDevice {
+        int Activate(ref Guid iid, int dwClsCtx, IntPtr pActivationParams, [MarshalAs(UnmanagedType.IUnknown)] out object ppInterface);
+    }
+
+    [Guid("77AA99A0-1BD6-484F-8BC7-2C654C9A9B6F"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    interface IAudioSessionManager2 {
+        int _0(); // QueryInterface stuff
+        int _1();
+        int GetSessionEnumerator(out IAudioSessionEnumerator ppEnum);
+    }
+
+    [Guid("E2F5BB11-0570-40CA-ACDD-3AA01277DEE8"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    interface IAudioSessionEnumerator {
+        int GetCount(out int count);
+        int GetSession(int index, [MarshalAs(UnmanagedType.IUnknown)] out object ppSession);
+    }
+
+    public static string GetSessions() {
+        // For now, use a simpler approach via Get-Process
+        return "use_powershell";
+    }
+}
+'@ -ErrorAction SilentlyContinue
+
+# Use the Volume Mixer approach via Get-Process with audio
+$sessions = Get-Process | Where-Object { $_.MainWindowTitle -ne '' -or $_.ProcessName -match 'chrome|firefox|spotify|vlc|teams|discord|zoom|music|video|media' } |
+  Select-Object Id, ProcessName, MainWindowTitle |
+  Sort-Object ProcessName -Unique
+
+$sessions | ForEach-Object {
+  [PSCustomObject]@{
+    PID = $_.Id
+    Name = $_.ProcessName
+    Title = $_.MainWindowTitle
+  }
+} | 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 };
+			}
+
+			if (!app && volume === undefined && !mute) {
+				// List mode
+				if (!result.stdout) {
+					return { content: [{ type: 'text', text: 'No audio app sessions detected.' }] };
+				}
+				const apps = Array.isArray(JSON.parse(result.stdout)) ? JSON.parse(result.stdout) : [JSON.parse(result.stdout)];
+				const lines = apps.map((a: { PID: number; Name: string; Title: string }) =>
+					`PID ${String(a.PID).padStart(6)}  ${a.Name.padEnd(25)}  ${a.Title || '(no window)'}`,
+				);
+				return {
+					content: [{ type: 'text', text: `Audio-capable processes:\n\n${lines.join('\n')}\n\nNote: Per-app volume control requires the SndVol COM API. Use windows_audio_set for master volume.` }],
+				};
+			}
+
+			return {
+				content: [{ type: 'text', text: `Per-app volume set/mute requires elevated SndVol COM access. Use windows_execute with PowerShell to control specific app audio, or use windows_audio_set for master volume.` }],
+			};
+		},
+	);
+}

package/src/tools/automation.ts

@@ -0,0 +1,297 @@
+/* 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 { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import { runPowerShell } from '../shell.js';
+
+export function registerAutomationTools(server: McpServer): void {
+	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: string;
+
+			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: { Name: string }) => `  ${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 };
+		},
+	);
+}

package/src/tools/bluetooth.ts

@@ -0,0 +1,114 @@
+/* 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 { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import { runPowerShell } from '../shell.js';
+
+export function registerBluetoothTools(server: McpServer): void {
+	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: string[] = [
+				`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: string;
+
+			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,
+			};
+		},
+	);
+}