@mokoconsulting/mcp-windows 3.0.0

package/dist/tools/display.js

@@ -0,0 +1,256 @@
+/* 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 { 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) {
+    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) => [
+            `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 = [];
+        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;
+        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',
+                        data: data.toString('base64'),
+                        mimeType: 'image/png',
+                    }],
+            };
+        }
+        catch {
+            return { content: [{ type: 'text', text: `Screenshot captured at ${outPath} but failed to read back.` }] };
+        }
+    });
+}
+//# sourceMappingURL=display.js.map

package/dist/tools/drives.d.ts

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

package/dist/tools/drives.js

@@ -0,0 +1,98 @@
+/* Copyright (C) 2026 Moko Consulting <hello@mokoconsulting.tech>
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ * Tools: windows_drives (#24), windows_file_search (#25)
+ */
+import { z } from 'zod';
+import { runPowerShell } from '../shell.js';
+export function registerDriveTools(server) {
+    server.tool('windows_drives', 'List all drives/volumes with type, label, capacity, free space, and usage percentage.', {}, async () => {
+        const ps = `
+Get-CimInstance Win32_LogicalDisk | ForEach-Object {
+  $typeMap = @{0='Unknown';1='No Root';2='Removable';3='Local';4='Network';5='CD/DVD';6='RAM Disk'}
+  [PSCustomObject]@{
+    Drive = $_.DeviceID
+    Label = $_.VolumeName
+    Type = $typeMap[[int]$_.DriveType]
+    FileSystem = $_.FileSystem
+    TotalGB = if ($_.Size) { [math]::Round($_.Size / 1GB, 1) } else { 0 }
+    FreeGB = if ($_.FreeSpace) { [math]::Round($_.FreeSpace / 1GB, 1) } else { 0 }
+    UsedPct = if ($_.Size -gt 0) { [math]::Round(($_.Size - $_.FreeSpace) / $_.Size * 100, 1) } else { 0 }
+  }
+} | 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 drives = Array.isArray(JSON.parse(result.stdout)) ? JSON.parse(result.stdout) : [JSON.parse(result.stdout)];
+        const lines = drives.map((d) => {
+            const bar = d.TotalGB > 0 ? makeBar(d.UsedPct) : '       ';
+            return `${d.Drive}  ${(d.Label || '').padEnd(15).slice(0, 15)}  ${d.Type.padEnd(10)}  ${d.FileSystem?.padEnd(5) || '     '}  ${String(d.FreeGB).padStart(8)}/${String(d.TotalGB).padStart(8)} GB  ${bar} ${d.UsedPct}%`;
+        });
+        const header = `Drv  ${'Label'.padEnd(15)}  ${'Type'.padEnd(10)}  FS     ${'Free'.padStart(8)}/${'Total'.padStart(8)}      Usage`;
+        return {
+            content: [{ type: 'text', text: `${header}\n${'─'.repeat(90)}\n${lines.join('\n')}` }],
+        };
+    });
+    server.tool('windows_file_search', 'Search for files using Windows Search index (fast) or filesystem walk (fallback). Search by name or content.', {
+        query: z.string().describe('Search query (filename pattern or content text)'),
+        path: z.string().default('C:\\').describe('Directory to search in'),
+        type: z.enum(['name', 'content']).default('name').describe('Search by filename or file content'),
+        extension: z.string().optional().describe('File extension filter (e.g. ".txt", ".log")'),
+        limit: z.number().default(30).describe('Max results'),
+    }, async ({ query, path, type, extension, limit }) => {
+        const extFilter = extension
+            ? `| Where-Object { $_.Extension -eq '${extension.replace(/'/g, "''")}' }`
+            : '';
+        let ps;
+        if (type === 'name') {
+            ps = `
+Get-ChildItem -Path '${path.replace(/'/g, "''")}' -Recurse -File -ErrorAction SilentlyContinue ${extFilter ? '' : ''} |
+  Where-Object { $_.Name -like '*${query.replace(/'/g, "''")}*' } ${extFilter} |
+  Select-Object -First ${limit} |
+  ForEach-Object {
+    [PSCustomObject]@{
+      Path = $_.FullName
+      Size = $_.Length
+      Modified = $_.LastWriteTime.ToString('yyyy-MM-dd HH:mm')
+      Extension = $_.Extension
+    }
+  } | ConvertTo-Json -Depth 3 -Compress`;
+        }
+        else {
+            ps = `
+Get-ChildItem -Path '${path.replace(/'/g, "''")}' -Recurse -File -ErrorAction SilentlyContinue ${extFilter} |
+  Select-String -Pattern '${query.replace(/'/g, "''")}' -List -ErrorAction SilentlyContinue |
+  Select-Object -First ${limit} |
+  ForEach-Object {
+    [PSCustomObject]@{
+      Path = $_.Path
+      Line = $_.LineNumber
+      Match = $_.Line.Trim().Substring(0, [math]::Min($_.Line.Trim().Length, 120))
+    }
+  } | ConvertTo-Json -Depth 3 -Compress`;
+        }
+        const result = await runPowerShell(ps, { timeout: 60000 });
+        if (result.exitCode !== 0) {
+            return { content: [{ type: 'text', text: `Error: ${result.stderr}` }], isError: true };
+        }
+        if (!result.stdout) {
+            return { content: [{ type: 'text', text: 'No results found.' }] };
+        }
+        const results = Array.isArray(JSON.parse(result.stdout)) ? JSON.parse(result.stdout) : [JSON.parse(result.stdout)];
+        let text;
+        if (type === 'name') {
+            text = results.map((r) => `${String(r.Size).padStart(10)}  ${r.Modified}  ${r.Path}`).join('\n');
+            text = `${'Size'.padStart(10)}  ${'Modified'.padEnd(16)}  Path\n${'─'.repeat(80)}\n${text}`;
+        }
+        else {
+            text = results.map((r) => `${r.Path}:${r.Line}: ${r.Match}`).join('\n');
+        }
+        return { content: [{ type: 'text', text: `${results.length} result(s):\n\n${text}` }] };
+    });
+}
+function makeBar(pct) {
+    const filled = Math.round(pct / 10);
+    return '[' + '█'.repeat(filled) + '░'.repeat(10 - filled) + ']';
+}
+//# sourceMappingURL=drives.js.map

package/dist/tools/environment.d.ts

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

package/dist/tools/environment.js

@@ -0,0 +1,129 @@
+/* Copyright (C) 2026 Moko Consulting <hello@mokoconsulting.tech>
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ * Tools: windows_env_get (#31), windows_env_set (#32)
+ */
+import { z } from 'zod';
+import { runPowerShell } from '../shell.js';
+export function registerEnvironmentTools(server) {
+    server.tool('windows_env_get', 'Get environment variables. Can retrieve a specific variable or list all (user, system, or both).', {
+        name: z.string().optional().describe('Variable name (omit to list all)'),
+        scope: z.enum(['user', 'system', 'both']).default('both').describe('Variable scope'),
+    }, async ({ name, scope }) => {
+        if (name) {
+            if (name.toUpperCase() === 'PATH') {
+                const ps = `
+$userPath = [Environment]::GetEnvironmentVariable('PATH', 'User')
+$sysPath = [Environment]::GetEnvironmentVariable('PATH', 'Machine')
+[PSCustomObject]@{
+  UserPATH = ($userPath -split ';' | Where-Object { $_ })
+  SystemPATH = ($sysPath -split ';' | Where-Object { $_ })
+} | 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 p = JSON.parse(result.stdout);
+                const userPaths = Array.isArray(p.UserPATH) ? p.UserPATH : [p.UserPATH].filter(Boolean);
+                const sysPaths = Array.isArray(p.SystemPATH) ? p.SystemPATH : [p.SystemPATH].filter(Boolean);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `System PATH (${sysPaths.length} entries):\n${sysPaths.map((p) => `  ${p}`).join('\n')}\n\nUser PATH (${userPaths.length} entries):\n${userPaths.map((p) => `  ${p}`).join('\n')}`,
+                        }],
+                };
+            }
+            const ps = `
+$user = [Environment]::GetEnvironmentVariable('${name.replace(/'/g, "''")}', 'User')
+$sys = [Environment]::GetEnvironmentVariable('${name.replace(/'/g, "''")}', 'Machine')
+$proc = [Environment]::GetEnvironmentVariable('${name.replace(/'/g, "''")}', 'Process')
+[PSCustomObject]@{ Name = '${name.replace(/'/g, "''")}'; User = $user; System = $sys; Process = $proc } | 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 v = JSON.parse(result.stdout);
+            const lines = [`${v.Name}:`];
+            if (v.System !== null)
+                lines.push(`  System:  ${v.System}`);
+            if (v.User !== null)
+                lines.push(`  User:    ${v.User}`);
+            if (v.Process !== null && v.Process !== v.System && v.Process !== v.User)
+                lines.push(`  Process: ${v.Process}`);
+            if (v.System === null && v.User === null)
+                lines.push('  (not set)');
+            return { content: [{ type: 'text', text: lines.join('\n') }] };
+        }
+        // List all
+        const scopes = scope === 'both' ? ['User', 'Machine'] : [scope === 'user' ? 'User' : 'Machine'];
+        const parts = [];
+        for (const s of scopes) {
+            const ps = `[Environment]::GetEnvironmentVariables('${s}').GetEnumerator() | Sort-Object Name | ForEach-Object { [PSCustomObject]@{ Name = $_.Name; Value = $_.Value } } | ConvertTo-Json -Depth 3 -Compress`;
+            const result = await runPowerShell(ps, { timeout: 10000 });
+            if (result.exitCode !== 0)
+                continue;
+            if (!result.stdout)
+                continue;
+            const vars = Array.isArray(JSON.parse(result.stdout)) ? JSON.parse(result.stdout) : [JSON.parse(result.stdout)];
+            const lines = vars.map((v) => `  ${v.Name.padEnd(30)}  ${(v.Value || '').slice(0, 60)}`);
+            parts.push(`${s} Variables (${vars.length}):\n${lines.join('\n')}`);
+        }
+        return { content: [{ type: 'text', text: parts.join('\n\n') }] };
+    });
+    server.tool('windows_env_set', 'Set or remove a persistent environment variable (user or system scope).', {
+        name: z.string().describe('Variable name'),
+        value: z.string().optional().describe('Value to set (omit with action=remove to delete)'),
+        scope: z.enum(['user', 'system']).default('user').describe('Variable scope'),
+        action: z.enum(['set', 'remove', 'append_path', 'prepend_path']).default('set').describe('Action'),
+    }, async ({ name, value, scope, action }) => {
+        const target = scope === 'user' ? 'User' : 'Machine';
+        let ps;
+        switch (action) {
+            case 'set':
+                if (!value) {
+                    return { content: [{ type: 'text', text: 'Set requires a value.' }], isError: true };
+                }
+                ps = `[Environment]::SetEnvironmentVariable('${name.replace(/'/g, "''")}', '${value.replace(/'/g, "''")}', '${target}'); "Set ${name}=${value} (${target})"`;
+                break;
+            case 'remove':
+                ps = `[Environment]::SetEnvironmentVariable('${name.replace(/'/g, "''")}', $null, '${target}'); "Removed ${name} (${target})"`;
+                break;
+            case 'append_path':
+                if (!value) {
+                    return { content: [{ type: 'text', text: 'append_path requires a value.' }], isError: true };
+                }
+                ps = `
+$current = [Environment]::GetEnvironmentVariable('PATH', '${target}')
+$entries = $current -split ';' | Where-Object { $_ }
+if ('${value.replace(/'/g, "''")}' -notin $entries) {
+  $new = ($entries + '${value.replace(/'/g, "''")}') -join ';'
+  [Environment]::SetEnvironmentVariable('PATH', $new, '${target}')
+  "Appended '${value}' to ${target} PATH"
+} else {
+  "'${value}' already in ${target} PATH"
+}`;
+                break;
+            case 'prepend_path':
+                if (!value) {
+                    return { content: [{ type: 'text', text: 'prepend_path requires a value.' }], isError: true };
+                }
+                ps = `
+$current = [Environment]::GetEnvironmentVariable('PATH', '${target}')
+$entries = $current -split ';' | Where-Object { $_ }
+if ('${value.replace(/'/g, "''")}' -notin $entries) {
+  $new = ('${value.replace(/'/g, "''")}' + ';' + ($entries -join ';'))
+  [Environment]::SetEnvironmentVariable('PATH', $new, '${target}')
+  "Prepended '${value}' to ${target} PATH"
+} else {
+  "'${value}' already in ${target} PATH"
+}`;
+                break;
+        }
+        const result = await runPowerShell(ps, { timeout: 10000 });
+        return {
+            content: [{ type: 'text', text: result.stdout || result.stderr }],
+            isError: result.exitCode !== 0,
+        };
+    });
+}
+//# sourceMappingURL=environment.js.map

package/dist/tools/execute.d.ts

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

package/dist/tools/execute.js

@@ -0,0 +1,28 @@
+/* Copyright (C) 2026 Moko Consulting <hello@mokoconsulting.tech>
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ * Tool: windows_execute — Execute shell commands (#1)
+ */
+import { z } from 'zod';
+import { runShell } from '../shell.js';
+export function registerExecuteTools(server) {
+    server.tool('windows_execute', 'Execute a shell command (PowerShell, cmd, or bash). Returns stdout, stderr, and exit code.', {
+        command: z.string().describe('The command to execute'),
+        shell: z.enum(['pwsh', 'cmd', 'bash']).default('pwsh').describe('Shell to use'),
+        timeout: z.number().optional().describe('Timeout in milliseconds (default 30000)'),
+        cwd: z.string().optional().describe('Working directory'),
+    }, async ({ command, shell, timeout, cwd }) => {
+        const result = await runShell(command, { shell, timeout, cwd });
+        const parts = [];
+        if (result.stdout)
+            parts.push(result.stdout);
+        if (result.stderr)
+            parts.push(`[stderr]\n${result.stderr}`);
+        parts.push(`[exit code: ${result.exitCode}]`);
+        return {
+            content: [{ type: 'text', text: parts.join('\n\n') }],
+            isError: result.exitCode !== 0,
+        };
+    });
+}
+//# sourceMappingURL=execute.js.map

package/dist/tools/filesystem.d.ts

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