@mokoconsulting/mcp-windows 3.0.0

package/src/tools/window.ts

@@ -0,0 +1,211 @@
+/* Copyright (C) 2026 Moko Consulting <hello@mokoconsulting.tech>
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ * Tools: windows_window_list (#14), windows_window_control (#15)
+ */
+
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import { runPowerShell } from '../shell.js';
+
+const WIN32_TYPES = `
+Add-Type @'
+using System;
+using System.Text;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+public class WindowManager {
+    [DllImport("user32.dll")] public static extern bool EnumWindows(EnumWindowsProc lpEnumFunc, IntPtr lParam);
+    [DllImport("user32.dll")] public static extern bool IsWindowVisible(IntPtr hWnd);
+    [DllImport("user32.dll", CharSet = CharSet.Auto)] public static extern int GetWindowText(IntPtr hWnd, StringBuilder text, int count);
+    [DllImport("user32.dll")] public static extern int GetWindowTextLength(IntPtr hWnd);
+    [DllImport("user32.dll")] public static extern bool GetWindowRect(IntPtr hWnd, out RECT lpRect);
+    [DllImport("user32.dll")] public static extern uint GetWindowThreadProcessId(IntPtr hWnd, out uint lpdwProcessId);
+    [DllImport("user32.dll")] public static extern bool ShowWindow(IntPtr hWnd, int nCmdShow);
+    [DllImport("user32.dll")] public static extern bool SetForegroundWindow(IntPtr hWnd);
+    [DllImport("user32.dll")] public static extern bool MoveWindow(IntPtr hWnd, int X, int Y, int nWidth, int nHeight, bool bRepaint);
+    [DllImport("user32.dll")] public static extern bool SetWindowPos(IntPtr hWnd, IntPtr hWndInsertAfter, int X, int Y, int cx, int cy, uint uFlags);
+    [DllImport("user32.dll")] public static extern bool IsIconic(IntPtr hWnd);
+    [DllImport("user32.dll")] public static extern bool IsZoomed(IntPtr hWnd);
+    [DllImport("user32.dll")] public static extern bool PostMessage(IntPtr hWnd, uint Msg, IntPtr wParam, IntPtr lParam);
+
+    public delegate bool EnumWindowsProc(IntPtr hWnd, IntPtr lParam);
+
+    [StructLayout(LayoutKind.Sequential)]
+    public struct RECT { public int Left, Top, Right, Bottom; }
+
+    public static readonly IntPtr HWND_TOPMOST = new IntPtr(-1);
+    public static readonly IntPtr HWND_NOTOPMOST = new IntPtr(-2);
+    public const uint SWP_NOMOVE = 0x0002;
+    public const uint SWP_NOSIZE = 0x0001;
+    public const uint WM_CLOSE = 0x0010;
+}
+'@ -ErrorAction SilentlyContinue
+`;
+
+export function registerWindowTools(server: McpServer): void {
+	server.tool(
+		'windows_window_list',
+		'List all visible windows with title, PID, process name, position, size, and state.',
+		{
+			filter: z.string().optional().describe('Filter by window title (substring)'),
+		},
+		async ({ filter }) => {
+			const filterClause = filter
+				? `| Where-Object { $_.Title -like '*${filter.replace(/'/g, "''")}*' }`
+				: '';
+
+			const ps = `
+${WIN32_TYPES}
+$windows = [System.Collections.Generic.List[PSObject]]::new()
+$zOrder = 0
+[WindowManager]::EnumWindows({
+  param($hWnd, $lParam)
+  if (-not [WindowManager]::IsWindowVisible($hWnd)) { return $true }
+  $len = [WindowManager]::GetWindowTextLength($hWnd)
+  if ($len -eq 0) { return $true }
+  $sb = New-Object System.Text.StringBuilder($len + 1)
+  [WindowManager]::GetWindowText($hWnd, $sb, $sb.Capacity) | Out-Null
+  $title = $sb.ToString()
+  if (-not $title) { return $true }
+
+  $pid = [uint32]0
+  [WindowManager]::GetWindowThreadProcessId($hWnd, [ref]$pid) | Out-Null
+  $proc = Get-Process -Id $pid -ErrorAction SilentlyContinue
+
+  $rect = New-Object WindowManager+RECT
+  [WindowManager]::GetWindowRect($hWnd, [ref]$rect) | Out-Null
+
+  $state = 'Normal'
+  if ([WindowManager]::IsIconic($hWnd)) { $state = 'Minimized' }
+  elseif ([WindowManager]::IsZoomed($hWnd)) { $state = 'Maximized' }
+
+  $script:windows.Add([PSCustomObject]@{
+    ZOrder = $script:zOrder++
+    Title = $title
+    PID = $pid
+    Process = if ($proc) { $proc.ProcessName } else { '?' }
+    X = $rect.Left
+    Y = $rect.Top
+    Width = $rect.Right - $rect.Left
+    Height = $rect.Bottom - $rect.Top
+    State = $state
+  })
+  return $true
+}, [IntPtr]::Zero) | Out-Null
+
+$windows ${filterClause} | 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 (!result.stdout) {
+				return { content: [{ type: 'text', text: 'No visible windows found.' }] };
+			}
+
+			const windows = Array.isArray(JSON.parse(result.stdout)) ? JSON.parse(result.stdout) : [JSON.parse(result.stdout)];
+			const lines = windows.map((w: { ZOrder: number; Title: string; PID: number; Process: string; X: number; Y: number; Width: number; Height: number; State: string }) => {
+				const stateIcon = w.State === 'Minimized' ? '[-]' : w.State === 'Maximized' ? '[+]' : '[ ]';
+				return `${stateIcon} ${String(w.PID).padStart(6)}  ${w.Process.padEnd(20).slice(0, 20)}  ${String(w.Width).padStart(5)}x${String(w.Height).padEnd(5)}  (${w.X},${w.Y})  ${w.Title.slice(0, 60)}`;
+			});
+
+			const header = `Sta  ${'PID'.padStart(6)}  ${'Process'.padEnd(20)}  ${'Size'.padStart(11)}  Pos       Title`;
+			return {
+				content: [{ type: 'text', text: `${header}\n${'─'.repeat(110)}\n${lines.join('\n')}\n\n${windows.length} windows` }],
+			};
+		},
+	);
+
+	server.tool(
+		'windows_window_control',
+		'Move, resize, minimize, maximize, restore, close, or focus a window.',
+		{
+			title: z.string().optional().describe('Window title (substring match)'),
+			pid: z.number().optional().describe('Process ID'),
+			action: z.enum(['minimize', 'maximize', 'restore', 'close', 'focus', 'move', 'resize', 'topmost']).describe('Action'),
+			x: z.number().optional().describe('X position (for move)'),
+			y: z.number().optional().describe('Y position (for move)'),
+			width: z.number().optional().describe('Width (for resize)'),
+			height: z.number().optional().describe('Height (for resize)'),
+			topmost: z.boolean().optional().describe('Set always-on-top (for topmost action)'),
+		},
+		async ({ title, pid, action, x, y, width, height, topmost }) => {
+			if (!title && !pid) {
+				return { content: [{ type: 'text', text: 'Provide either title or pid.' }], isError: true };
+			}
+
+			const findWindow = title
+				? `
+$target = '${title.replace(/'/g, "''")}'
+$hWnd = [IntPtr]::Zero
+[WindowManager]::EnumWindows({
+  param($h, $l)
+  $sb = New-Object System.Text.StringBuilder 256
+  [WindowManager]::GetWindowText($h, $sb, 256) | Out-Null
+  if ($sb.ToString() -like "*$target*" -and [WindowManager]::IsWindowVisible($h)) {
+    $script:hWnd = $h; return $false
+  }
+  return $true
+}, [IntPtr]::Zero) | Out-Null
+if ($hWnd -eq [IntPtr]::Zero) { throw "Window not found: $target" }`
+				: `
+$proc = Get-Process -Id ${pid} -ErrorAction Stop
+$hWnd = $proc.MainWindowHandle
+if ($hWnd -eq [IntPtr]::Zero) { throw "Process ${pid} has no visible window" }`;
+
+			let actionCode: string;
+			switch (action) {
+				case 'minimize':
+					actionCode = `[WindowManager]::ShowWindow($hWnd, 6) | Out-Null; "Minimized"`;
+					break;
+				case 'maximize':
+					actionCode = `[WindowManager]::ShowWindow($hWnd, 3) | Out-Null; "Maximized"`;
+					break;
+				case 'restore':
+					actionCode = `[WindowManager]::ShowWindow($hWnd, 9) | Out-Null; "Restored"`;
+					break;
+				case 'close':
+					actionCode = `[WindowManager]::PostMessage($hWnd, [WindowManager]::WM_CLOSE, [IntPtr]::Zero, [IntPtr]::Zero) | Out-Null; "Close message sent"`;
+					break;
+				case 'focus':
+					actionCode = `[WindowManager]::ShowWindow($hWnd, 9) | Out-Null; [WindowManager]::SetForegroundWindow($hWnd) | Out-Null; "Focused"`;
+					break;
+				case 'move':
+					if (x === undefined || y === undefined) {
+						return { content: [{ type: 'text', text: 'Move requires x and y.' }], isError: true };
+					}
+					actionCode = `
+$rect = New-Object WindowManager+RECT
+[WindowManager]::GetWindowRect($hWnd, [ref]$rect) | Out-Null
+$w = $rect.Right - $rect.Left; $h = $rect.Bottom - $rect.Top
+[WindowManager]::MoveWindow($hWnd, ${x}, ${y}, $w, $h, $true) | Out-Null
+"Moved to (${x}, ${y})"`;
+					break;
+				case 'resize':
+					if (!width || !height) {
+						return { content: [{ type: 'text', text: 'Resize requires width and height.' }], isError: true };
+					}
+					actionCode = `
+$rect = New-Object WindowManager+RECT
+[WindowManager]::GetWindowRect($hWnd, [ref]$rect) | Out-Null
+[WindowManager]::MoveWindow($hWnd, $rect.Left, $rect.Top, ${width}, ${height}, $true) | Out-Null
+"Resized to ${width}x${height}"`;
+					break;
+				case 'topmost':
+					const insertAfter = topmost !== false ? '[WindowManager]::HWND_TOPMOST' : '[WindowManager]::HWND_NOTOPMOST';
+					actionCode = `[WindowManager]::SetWindowPos($hWnd, ${insertAfter}, 0, 0, 0, 0, [WindowManager]::SWP_NOMOVE -bor [WindowManager]::SWP_NOSIZE) | Out-Null; "Topmost: ${topmost !== false}"`;
+					break;
+			}
+
+			const ps = `${WIN32_TYPES}\n${findWindow}\n${actionCode}`;
+			const result = await runPowerShell(ps, { timeout: 10000 });
+			return {
+				content: [{ type: 'text', text: result.stdout || result.stderr }],
+				isError: result.exitCode !== 0,
+			};
+		},
+	);
+}

package/src/tools/winget.ts

@@ -0,0 +1,100 @@
+/* Copyright (C) 2026 Moko Consulting <hello@mokoconsulting.tech>
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ * Tools: windows_winget_search (#69), windows_winget_manage (#70), windows_winget_export (#71)
+ */
+
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import { runShell } from '../shell.js';
+
+export function registerWingetTools(server: McpServer): void {
+	server.tool(
+		'windows_winget_search',
+		'Search for packages in the winget repository.',
+		{
+			query: z.string().describe('Search query (name or ID)'),
+			source: z.enum(['winget', 'msstore', 'all']).default('all').describe('Package source'),
+			limit: z.number().default(20).describe('Max results'),
+		},
+		async ({ query, source, limit }) => {
+			const sourceArg = source !== 'all' ? `--source ${source}` : '';
+			const cmd = `winget search "${query}" ${sourceArg} --count ${limit} --accept-source-agreements --disable-interactivity`;
+			const result = await runShell(cmd, { shell: 'cmd', timeout: 30000 });
+			const clean = result.stdout.replace(/\0/g, '').trim();
+			return {
+				content: [{ type: 'text', text: clean || 'No packages found.' }],
+				isError: result.exitCode !== 0 && !clean,
+			};
+		},
+	);
+
+	server.tool(
+		'windows_winget_manage',
+		'Install, upgrade, or uninstall packages via winget. Also list installed or upgradable packages.',
+		{
+			action: z.enum(['install', 'upgrade', 'uninstall', 'list', 'upgradable', 'upgrade_all']).describe('Action'),
+			id: z.string().optional().describe('Package ID (e.g. "Microsoft.VisualStudioCode")'),
+			version: z.string().optional().describe('Specific version to install'),
+		},
+		async ({ action, id, version }) => {
+			let cmd: string;
+
+			switch (action) {
+				case 'install':
+					if (!id) return { content: [{ type: 'text', text: 'install requires id.' }], isError: true };
+					cmd = `winget install --id "${id}" ${version ? `--version "${version}"` : ''} --accept-package-agreements --accept-source-agreements --disable-interactivity`;
+					break;
+				case 'upgrade':
+					if (!id) return { content: [{ type: 'text', text: 'upgrade requires id.' }], isError: true };
+					cmd = `winget upgrade --id "${id}" --accept-package-agreements --accept-source-agreements --disable-interactivity`;
+					break;
+				case 'upgrade_all':
+					cmd = `winget upgrade --all --accept-package-agreements --accept-source-agreements --disable-interactivity`;
+					break;
+				case 'uninstall':
+					if (!id) return { content: [{ type: 'text', text: 'uninstall requires id.' }], isError: true };
+					cmd = `winget uninstall --id "${id}" --disable-interactivity`;
+					break;
+				case 'list':
+					cmd = `winget list --accept-source-agreements --disable-interactivity`;
+					break;
+				case 'upgradable':
+					cmd = `winget upgrade --accept-source-agreements --disable-interactivity`;
+					break;
+			}
+
+			const timeout = action === 'install' || action === 'upgrade' || action === 'upgrade_all' ? 300000 : 30000;
+			const result = await runShell(cmd, { shell: 'cmd', timeout });
+			const clean = result.stdout.replace(/\0/g, '').trim();
+
+			return {
+				content: [{ type: 'text', text: clean || result.stderr || `${action} completed.` }],
+				isError: result.exitCode !== 0 && !clean,
+			};
+		},
+	);
+
+	server.tool(
+		'windows_winget_export',
+		'Export installed packages to JSON or import from a JSON file.',
+		{
+			action: z.enum(['export', 'import']).describe('Action'),
+			path: z.string().describe('File path for export/import JSON'),
+		},
+		async ({ action, path }) => {
+			const cmd = action === 'export'
+				? `winget export -o "${path}" --accept-source-agreements --disable-interactivity`
+				: `winget import -i "${path}" --accept-package-agreements --accept-source-agreements --disable-interactivity`;
+
+			const timeout = action === 'import' ? 600000 : 30000;
+			const result = await runShell(cmd, { shell: 'cmd', timeout });
+			const clean = result.stdout.replace(/\0/g, '').trim();
+
+			return {
+				content: [{ type: 'text', text: clean || `${action} completed: ${path}` }],
+				isError: result.exitCode !== 0 && !clean,
+			};
+		},
+	);
+}

package/src/tools/wsl.ts

@@ -0,0 +1,112 @@
+/* Copyright (C) 2026 Moko Consulting <hello@mokoconsulting.tech>
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ * Tools: windows_wsl_list (#66), windows_wsl_manage (#67), windows_wsl_exec (#68)
+ */
+
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import { runShell, runPowerShell } from '../shell.js';
+
+export function registerWslTools(server: McpServer): void {
+	server.tool(
+		'windows_wsl_list',
+		'List installed WSL distributions with status, version, and default flag.',
+		{},
+		async () => {
+			// wsl.exe outputs UTF-16; use PowerShell to decode properly
+			const ps = `$out = wsl --list --verbose 2>&1; if ($LASTEXITCODE -ne 0) { "WSL_ERROR:$out" } else { $out }`;
+			const result = await runPowerShell(ps, { timeout: 15000 });
+			const clean = result.stdout.replace(/\0/g, '').trim();
+			if (clean.startsWith('WSL_ERROR:') || result.exitCode !== 0) {
+				const msg = clean.replace('WSL_ERROR:', '').trim();
+				return { content: [{ type: 'text', text: msg || 'WSL is not installed or not available. Install with: wsl --install' }] };
+			}
+			return { content: [{ type: 'text', text: clean || 'No WSL distributions installed.' }] };
+		},
+	);
+
+	server.tool(
+		'windows_wsl_manage',
+		'Manage WSL: start, stop, shutdown, set default, export, import, or remove distros.',
+		{
+			action: z.enum(['shutdown', 'terminate', 'set_default', 'set_version', 'export', 'import', 'unregister']).describe('Action'),
+			distro: z.string().optional().describe('Distribution name'),
+			version: z.number().optional().describe('WSL version 1 or 2 (for set_version)'),
+			path: z.string().optional().describe('File path (for export/import)'),
+		},
+		async ({ action, distro, version, path }) => {
+			let cmd: string;
+
+			switch (action) {
+				case 'shutdown':
+					cmd = 'wsl --shutdown';
+					break;
+				case 'terminate':
+					if (!distro) return { content: [{ type: 'text', text: 'terminate requires distro.' }], isError: true };
+					cmd = `wsl --terminate ${distro}`;
+					break;
+				case 'set_default':
+					if (!distro) return { content: [{ type: 'text', text: 'set_default requires distro.' }], isError: true };
+					cmd = `wsl --set-default ${distro}`;
+					break;
+				case 'set_version':
+					if (!distro || !version) return { content: [{ type: 'text', text: 'set_version requires distro and version.' }], isError: true };
+					cmd = `wsl --set-version ${distro} ${version}`;
+					break;
+				case 'export':
+					if (!distro || !path) return { content: [{ type: 'text', text: 'export requires distro and path.' }], isError: true };
+					cmd = `wsl --export ${distro} "${path}"`;
+					break;
+				case 'import':
+					if (!distro || !path) return { content: [{ type: 'text', text: 'import requires distro and path.' }], isError: true };
+					cmd = `wsl --import ${distro} "C:\\WSL\\${distro}" "${path}"`;
+					break;
+				case 'unregister':
+					if (!distro) return { content: [{ type: 'text', text: 'unregister requires distro.' }], isError: true };
+					cmd = `wsl --unregister ${distro}`;
+					break;
+			}
+
+			const result = await runShell(cmd, { shell: 'cmd', timeout: 60000 });
+			const clean = (result.stdout + '\n' + result.stderr).replace(/\0/g, '').trim();
+			return {
+				content: [{ type: 'text', text: clean || `${action} completed.` }],
+				isError: result.exitCode !== 0,
+			};
+		},
+	);
+
+	server.tool(
+		'windows_wsl_exec',
+		'Execute a command inside a WSL distribution. Returns stdout, stderr, exit code.',
+		{
+			command: z.string().describe('Command to execute'),
+			distro: z.string().optional().describe('Distribution name (default distro if omitted)'),
+			user: z.string().optional().describe('Run as user'),
+			cwd: z.string().optional().describe('Working directory inside WSL'),
+			timeout: z.number().default(30000).describe('Timeout in ms'),
+		},
+		async ({ command, distro, user, cwd, timeout }) => {
+			const parts = ['wsl'];
+			if (distro) parts.push('-d', distro);
+			if (user) parts.push('-u', user);
+			if (cwd) parts.push('--cd', cwd);
+			parts.push('--', 'bash', '-c', `"${command.replace(/"/g, '\\"')}"`);
+
+			const result = await runShell(parts.join(' '), { shell: 'cmd', timeout });
+			const clean = result.stdout.replace(/\0/g, '').trim();
+			const cleanErr = result.stderr.replace(/\0/g, '').trim();
+
+			const output: string[] = [];
+			if (clean) output.push(clean);
+			if (cleanErr) output.push(`[stderr]\n${cleanErr}`);
+			output.push(`[exit code: ${result.exitCode}]`);
+
+			return {
+				content: [{ type: 'text', text: output.join('\n\n') }],
+				isError: result.exitCode !== 0,
+			};
+		},
+	);
+}

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+	"compilerOptions": {
+		"target": "ES2022",
+		"module": "Node16",
+		"moduleResolution": "Node16",
+		"outDir": "./dist",
+		"rootDir": "./src",
+		"strict": true,
+		"esModuleInterop": true,
+		"skipLibCheck": true,
+		"forceConsistentCasingInFileNames": true,
+		"resolveJsonModule": true,
+		"declaration": true,
+		"declarationMap": true,
+		"sourceMap": true
+	},
+	"include": ["src/**/*"],
+	"exclude": ["node_modules", "dist"]
+}