@mokoconsulting/mcp-windows 3.0.0

package/dist/tools/window.js

@@ -0,0 +1,189 @@
+/* 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 { 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) {
+    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) => {
+            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;
+        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,
+        };
+    });
+}
+//# sourceMappingURL=window.js.map

package/dist/tools/winget.d.ts

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

package/dist/tools/winget.js

@@ -0,0 +1,79 @@
+/* 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 { z } from 'zod';
+import { runShell } from '../shell.js';
+export function registerWingetTools(server) {
+    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;
+        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,
+        };
+    });
+}
+//# sourceMappingURL=winget.js.map

package/dist/tools/wsl.d.ts

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

package/dist/tools/wsl.js

@@ -0,0 +1,99 @@
+/* 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 { z } from 'zod';
+import { runShell, runPowerShell } from '../shell.js';
+export function registerWslTools(server) {
+    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;
+        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 = [];
+        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,
+        };
+    });
+}
+//# sourceMappingURL=wsl.js.map

package/docs/API.md

@@ -0,0 +1,63 @@
+<!--
+Copyright (C) 2026 Moko Consulting <hello@mokoconsulting.tech>
+SPDX-License-Identifier: GPL-3.0-or-later
+
+# FILE INFORMATION
+DEFGROUP: mcp_windows.Documentation
+PATH: /docs/API.md
+VERSION: 01.00.00
+BRIEF: MCP tool reference documentation
+-->
+
+# API Reference
+
+All tools accept an optional `connection` parameter to target a specific named connection. If omitted, the default connection is used.
+
+## Example Resources
+
+> Replace these example tools with your actual API tools.
+
+### `example_resources_list`
+List resources with optional search.
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `search` | string | No | Search query |
+| `limit` | number | No | Max results |
+| `page` | number | No | Page number (0-based) |
+
+### `example_resource_get`
+Get a single resource by ID.
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `id` | number | Yes | Resource ID |
+
+### `example_resource_create`
+Create a new resource.
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `name` | string | Yes | Resource name |
+| `description` | string | No | Resource description |
+
+## Generic
+
+### `api_request`
+Make a raw API request to any endpoint.
+
+| Parameter | Type | Required | Description |
+|-----------|------|----------|-------------|
+| `method` | `"GET"` / `"POST"` / `"PUT"` / `"PATCH"` / `"DELETE"` | Yes | HTTP method |
+| `endpoint` | string | Yes | API path |
+| `body` | object | No | Request body |
+| `params` | object | No | Query parameters |
+
+### `list_connections`
+List all configured connections. No parameters.
+
+## Revision History
+
+| Date | Version | Author | Notes |
+| --- | --- | --- | --- |
+| 2026-05-07 | 0.0.1 | jmiller | Initial template API reference |

package/docs/ARCHITECTURE.md

@@ -0,0 +1,73 @@
+<!--
+Copyright (C) 2026 Moko Consulting <hello@mokoconsulting.tech>
+SPDX-License-Identifier: GPL-3.0-or-later
+
+# FILE INFORMATION
+DEFGROUP: mcp_windows.Documentation
+PATH: /docs/ARCHITECTURE.md
+VERSION: 01.00.00
+BRIEF: Architecture overview and design decisions
+-->
+
+# Architecture
+
+## Overview
+
+mcp_windows is a Model Context Protocol (MCP) server that bridges AI assistants with a REST API.
+
+```
+AI Assistant  <-->  MCP (stdio)  <-->  ApiClient  <-->  REST API
+```
+
+## Components
+
+### `src/index.ts` — Server Entry Point
+
+Registers all MCP tools with `McpServer` from `@modelcontextprotocol/sdk`. Each tool maps to one or more API endpoints. Uses Zod schemas for input validation.
+
+Includes shared helpers:
+- `formatResponse()` — normalizes error/success responses into MCP text content
+- `paginationQuery()` — builds pagination query params
+- `ConnectionParam` / `PaginationParams` — reusable Zod parameter spreads
+
+### `src/client.ts` — HTTP Client
+
+The `ApiClient` class handles all HTTP communication:
+- Uses `node:https` / `node:http` (not `fetch`) for reliable self-signed cert support
+- Supports GET, POST, PUT, PATCH, DELETE
+- JSON serialization/deserialization with error handling
+
+### `src/config.ts` — Configuration Loader
+
+Loads connection details from `~/.<project>.json`. Supports multiple named connections with a configurable default.
+
+### `src/types.ts` — Type Definitions
+
+TypeScript interfaces for `ApiConnection`, `ApiConfig`, and `ApiResponse`.
+
+### `scripts/setup.mjs` — Interactive Setup
+
+Node.js script using `readline/promises` for interactive config creation.
+
+## Design Decisions
+
+### Why `node:https` instead of `fetch`?
+
+Node.js 24's built-in `fetch` does not honor self-signed certificate bypass. The classic `node:https` module with `rejectUnauthorized: false` works reliably across all Node.js versions.
+
+### Why multiple named connections?
+
+Multi-instance support is a core use case — managing staging, production, and dev environments from a single MCP server.
+
+## Data Flow
+
+1. AI assistant sends a tool call via MCP stdio transport
+2. `index.ts` validates parameters with Zod and resolves the connection
+3. `ApiClient` constructs the API URL, attaches auth headers, and makes the HTTP request
+4. Response is parsed as JSON and returned as MCP tool output
+
+## Revision History
+
+| Date | Version | Author | Notes |
+| --- | --- | --- | --- |
+| 2026-05-07 | 0.0.1 | jmiller | Initial architecture document |

package/docs/INSTALLATION.md

@@ -0,0 +1,102 @@
+<!--
+Copyright (C) 2026 Moko Consulting <hello@mokoconsulting.tech>
+SPDX-License-Identifier: GPL-3.0-or-later
+
+# FILE INFORMATION
+DEFGROUP: mcp_windows.Documentation
+PATH: /docs/INSTALLATION.md
+VERSION: 01.00.00
+BRIEF: Installation and setup instructions
+-->
+
+# Installation
+
+## Prerequisites
+
+- **Node.js** 20.0.0 or later
+- **npm** (included with Node.js)
+- Access to the target API with valid credentials
+
+## Install
+
+```sh
+git clone https://git.mokoconsulting.tech/MokoConsulting/mcp_windows.git
+cd mcp_windows
+npm install
+npm run build
+npm run setup
+```
+
+The setup wizard will prompt for:
+
+1. **Connection name** — a label for this instance (e.g. `production`, `staging`)
+2. **API URL** — the base URL of the instance
+3. **API key/token** — authentication credentials
+4. **TLS verification** — whether to skip certificate verification (for self-signed certs)
+
+Run `npm run setup` again to add more connections.
+
+## Register with Claude Code
+
+Add to your Claude Code MCP settings (`~/.claude.json` or project `.mcp.json`):
+
+```json
+{
+  "mcpServers": {
+    "mcp_windows": {
+      "type": "stdio",
+      "command": "node",
+      "args": ["/path/to/mcp_windows/dist/index.js"]
+    }
+  }
+}
+```
+
+Restart Claude Code after adding the server.
+
+## Configuration File
+
+The config is stored at `~/.mcp_windows.json`:
+
+```json
+{
+  "defaultConnection": "production",
+  "connections": {
+    "production": {
+      "baseUrl": "https://api.example.com",
+      "apiKey": "your-api-key"
+    },
+    "staging": {
+      "baseUrl": "https://api-staging.example.com",
+      "apiKey": "your-staging-key",
+      "insecure": true
+    }
+  }
+}
+```
+
+You can also set the `MCP_WINDOWS_CONFIG` environment variable to use a config file at a custom path.
+
+## Verification
+
+```sh
+npm start
+```
+
+If configured correctly, the server will start listening on stdio.
+
+## Troubleshooting
+
+### "Failed to load config" error
+Run `npm run setup` to create the config file.
+
+### Connection errors
+- Verify the API is reachable from your machine
+- For self-signed certs, set `"insecure": true`
+- Ensure the API key/token is valid
+
+## Revision History
+
+| Date | Version | Author | Notes |
+| --- | --- | --- | --- |
+| 2026-05-07 | 0.0.1 | jmiller | Initial installation guide |

package/docs/index.md

@@ -0,0 +1,12 @@
+<!-- Copyright (C) 2026 Moko Consulting <hello@mokoconsulting.tech>
+     SPDX-License-Identifier: GPL-3.0-or-later -->
+
+# mcp_windows Documentation
+
+See the [README](../README.md) for quick start, customization guide, and tool patterns.
+
+## Documents
+
+- [INSTALLATION.md](./INSTALLATION.md) — Prerequisites, install, setup, troubleshooting
+- [ARCHITECTURE.md](./ARCHITECTURE.md) — Component overview, design decisions, data flow
+- [API.md](./API.md) — Full MCP tool reference with parameter tables

package/package.json

@@ -0,0 +1,35 @@
+{
+	"name": "@mokoconsulting/mcp-windows",
+	"version": "3.0.0",
+	"description": "MCP server for Windows desktop system operations",
+	"type": "module",
+	"main": "dist/index.js",
+	"bin": {
+		"mcp-windows": "dist/index.js"
+	},
+	"scripts": {
+		"build": "tsc",
+		"dev": "tsc --watch",
+		"start": "node dist/index.js",
+		"lint": "eslint src/",
+		"setup": "node scripts/setup.mjs",
+		"clean": "rm -rf dist/"
+	},
+	"dependencies": {
+		"@modelcontextprotocol/sdk": "^1.12.1",
+		"zod": "^3.24.4"
+	},
+	"devDependencies": {
+		"@types/node": "^22.15.3",
+		"typescript": "^5.8.3"
+	},
+	"engines": {
+		"node": ">=20.0.0"
+	},
+	"license": "GPL-3.0-or-later",
+	"author": "Moko Consulting <hello@mokoconsulting.tech>",
+	"repository": {
+		"type": "git",
+		"url": "https://git.mokoconsulting.tech/MokoConsulting/mcp-windows.git"
+	}
+}