@mokoconsulting/mcp-windows 3.0.0

package/dist/tools/filesystem.js

@@ -0,0 +1,230 @@
+/* Copyright (C) 2026 Moko Consulting <hello@mokoconsulting.tech>
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ * Tools: windows_file_read (#36), windows_file_write (#37),
+ *        windows_file_edit (#38), windows_search (#39)
+ */
+import { z } from 'zod';
+import { readFile, writeFile, stat, mkdir } from 'node:fs/promises';
+import { dirname, resolve, extname } from 'node:path';
+import { runPowerShell } from '../shell.js';
+export function registerFilesystemTools(server) {
+    // ── windows_file_read ────────────────────────────────────────────────
+    server.tool('windows_file_read', 'Read a file with line pagination. Supports text, images (base64), and binary detection. Use negative offset for tail behavior.', {
+        path: z.string().describe('Absolute file path'),
+        offset: z.number().default(0).describe('Line offset (0-based, negative = from end)'),
+        length: z.number().default(200).describe('Number of lines to return'),
+    }, async ({ path: filePath, offset, length }) => {
+        try {
+            const absPath = resolve(filePath);
+            const ext = extname(absPath).toLowerCase();
+            // Image files → base64
+            if (['.png', '.jpg', '.jpeg', '.gif', '.webp', '.bmp', '.ico', '.svg'].includes(ext)) {
+                const data = await readFile(absPath);
+                const mimeMap = {
+                    '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg',
+                    '.gif': 'image/gif', '.webp': 'image/webp', '.bmp': 'image/bmp',
+                    '.ico': 'image/x-icon', '.svg': 'image/svg+xml',
+                };
+                return {
+                    content: [{
+                            type: 'image',
+                            data: data.toString('base64'),
+                            mimeType: mimeMap[ext] || 'application/octet-stream',
+                        }],
+                };
+            }
+            // Text files → line pagination
+            const content = await readFile(absPath, 'utf-8');
+            const allLines = content.split('\n');
+            const total = allLines.length;
+            let start;
+            if (offset < 0) {
+                start = Math.max(0, total + offset);
+            }
+            else {
+                start = Math.min(offset, total);
+            }
+            const end = Math.min(start + length, total);
+            const lines = allLines.slice(start, end);
+            const numbered = lines.map((line, i) => `${String(start + i + 1).padStart(5)}  ${line}`);
+            const header = `${absPath} — lines ${start + 1}-${end} of ${total}`;
+            return {
+                content: [{ type: 'text', text: `${header}\n${'─'.repeat(60)}\n${numbered.join('\n')}` }],
+            };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: `Error reading file: ${err}` }], isError: true };
+        }
+    });
+    // ── windows_file_write ───────────────────────────────────────────────
+    server.tool('windows_file_write', 'Write or append to a text file. Creates parent directories if needed.', {
+        path: z.string().describe('Absolute file path'),
+        content: z.string().describe('Content to write'),
+        mode: z.enum(['write', 'append']).default('write').describe('Write mode'),
+    }, async ({ path: filePath, content, mode }) => {
+        try {
+            const absPath = resolve(filePath);
+            await mkdir(dirname(absPath), { recursive: true });
+            if (mode === 'append') {
+                const existing = await readFile(absPath, 'utf-8').catch(() => '');
+                await writeFile(absPath, existing + content, 'utf-8');
+            }
+            else {
+                await writeFile(absPath, content, 'utf-8');
+            }
+            const info = await stat(absPath);
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Written: ${absPath} (${info.size} bytes, mode: ${mode})`,
+                    }],
+            };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: `Error writing file: ${err}` }], isError: true };
+        }
+    });
+    // ── windows_file_edit ────────────────────────────────────────────────
+    server.tool('windows_file_edit', 'Surgical file edit with find/replace. Validates expected replacement count.', {
+        path: z.string().describe('Absolute file path'),
+        old_string: z.string().describe('Text to find'),
+        new_string: z.string().describe('Replacement text'),
+        expected_count: z.number().optional().describe('Expected number of replacements (fails if mismatch)'),
+        replace_all: z.boolean().default(false).describe('Replace all occurrences'),
+    }, async ({ path: filePath, old_string, new_string, expected_count, replace_all }) => {
+        try {
+            const absPath = resolve(filePath);
+            const content = await readFile(absPath, 'utf-8');
+            // Count occurrences
+            let count = 0;
+            let idx = 0;
+            while ((idx = content.indexOf(old_string, idx)) !== -1) {
+                count++;
+                idx += old_string.length;
+            }
+            if (count === 0) {
+                // Try to find near-matches for helpful error
+                const lines = content.split('\n');
+                const needle = old_string.trim().split('\n')[0].trim();
+                const nearMatches = lines
+                    .map((line, i) => ({ line: line.trim(), num: i + 1 }))
+                    .filter(({ line }) => {
+                    if (!needle)
+                        return false;
+                    // Simple similarity: shared words
+                    const words = needle.toLowerCase().split(/\s+/);
+                    const lineWords = line.toLowerCase().split(/\s+/);
+                    const shared = words.filter(w => lineWords.includes(w)).length;
+                    return shared >= Math.ceil(words.length * 0.5);
+                })
+                    .slice(0, 3);
+                let msg = `No matches found for the specified text.`;
+                if (nearMatches.length > 0) {
+                    msg += `\n\nNear matches:\n${nearMatches.map(m => `  Line ${m.num}: ${m.line}`).join('\n')}`;
+                }
+                return { content: [{ type: 'text', text: msg }], isError: true };
+            }
+            if (expected_count !== undefined && count !== expected_count) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `Expected ${expected_count} occurrence(s) but found ${count}. No changes made.`,
+                        }],
+                    isError: true,
+                };
+            }
+            let result;
+            if (replace_all) {
+                result = content.split(old_string).join(new_string);
+            }
+            else {
+                const pos = content.indexOf(old_string);
+                result = content.slice(0, pos) + new_string + content.slice(pos + old_string.length);
+            }
+            await writeFile(absPath, result, 'utf-8');
+            const replaced = replace_all ? count : 1;
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Replaced ${replaced} occurrence(s) in ${absPath}`,
+                    }],
+            };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: `Error editing file: ${err}` }], isError: true };
+        }
+    });
+    // ── windows_search ───────────────────────────────────────────────────
+    server.tool('windows_search', 'Search for files by name pattern or search file contents. Uses ripgrep if available, falls back to PowerShell.', {
+        type: z.enum(['files', 'content']).describe('Search type: "files" for filename, "content" for inside files'),
+        pattern: z.string().describe('Search pattern (glob for files, regex or literal for content)'),
+        path: z.string().default('.').describe('Directory to search in'),
+        case_sensitive: z.boolean().default(false).describe('Case-sensitive search'),
+        file_pattern: z.string().optional().describe('Filter files by pattern (e.g. "*.ts") — only for content search'),
+        context_lines: z.number().default(0).describe('Lines of context around content matches'),
+        limit: z.number().default(50).describe('Max results'),
+    }, async ({ type, pattern, path: searchPath, case_sensitive, file_pattern, context_lines, limit }) => {
+        const absPath = resolve(searchPath);
+        if (type === 'files') {
+            const caseSense = case_sensitive ? '' : '-i';
+            const ps = `
+Get-ChildItem -Path '${absPath.replace(/'/g, "''")}' -Recurse -File -ErrorAction SilentlyContinue |
+  Where-Object { $_.Name ${caseSense ? '-cmatch' : '-match'} '${pattern.replace(/'/g, "''")}' } |
+  Select-Object -First ${limit} |
+  ForEach-Object {
+    "$($_.Length.ToString().PadLeft(10)) $($_.LastWriteTime.ToString('yyyy-MM-dd HH:mm')) $($_.FullName)"
+  }`;
+            const result = await runPowerShell(ps, { timeout: 30000 });
+            if (result.exitCode !== 0) {
+                return { content: [{ type: 'text', text: `Error: ${result.stderr}` }], isError: true };
+            }
+            const lines = result.stdout ? result.stdout.split('\n') : [];
+            return {
+                content: [{
+                        type: 'text',
+                        text: lines.length > 0
+                            ? `${lines.length} file(s) found:\n\n${'      Size  Modified          Path'}\n${lines.join('\n')}`
+                            : 'No files found.',
+                    }],
+            };
+        }
+        // Content search — try ripgrep first, fall back to PowerShell
+        const caseFlag = case_sensitive ? '' : '-i';
+        const contextFlag = context_lines > 0 ? `-C ${context_lines}` : '';
+        const fileFlag = file_pattern ? `--glob '${file_pattern}'` : '';
+        // Try rg first
+        const rgCmd = `rg ${caseFlag} ${contextFlag} ${fileFlag} --max-count 5 -n '${pattern.replace(/'/g, "\\'")}' '${absPath.replace(/'/g, "\\'")}'`;
+        const rgResult = await runPowerShell(`& { ${rgCmd} } 2>$null | Select-Object -First ${limit * 3}`, { timeout: 30000 });
+        if (rgResult.exitCode === 0 && rgResult.stdout) {
+            const lines = rgResult.stdout.split('\n');
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Content search results (ripgrep):\n\n${lines.join('\n')}`,
+                    }],
+            };
+        }
+        // Fallback: PowerShell Select-String
+        const fileFilter = file_pattern ? `-Include '${file_pattern}'` : '';
+        const ps = `
+Get-ChildItem -Path '${absPath.replace(/'/g, "''")}' -Recurse -File ${fileFilter} -ErrorAction SilentlyContinue |
+  Select-String -Pattern '${pattern.replace(/'/g, "''")}' ${case_sensitive ? '-CaseSensitive' : ''} -Context ${context_lines} |
+  Select-Object -First ${limit} |
+  ForEach-Object { "$($_.Path):$($_.LineNumber): $($_.Line.Trim())" }`;
+        const result = await runPowerShell(ps, { timeout: 60000 });
+        if (result.exitCode !== 0) {
+            return { content: [{ type: 'text', text: `Error: ${result.stderr}` }], isError: true };
+        }
+        const lines = result.stdout ? result.stdout.split('\n') : [];
+        return {
+            content: [{
+                    type: 'text',
+                    text: lines.length > 0
+                        ? `${lines.length} match(es) found:\n\n${lines.join('\n')}`
+                        : 'No matches found.',
+                }],
+        };
+    });
+}
+//# sourceMappingURL=filesystem.js.map

package/dist/tools/firewall.d.ts

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

package/dist/tools/firewall.js

@@ -0,0 +1,108 @@
+/* Copyright (C) 2026 Moko Consulting <hello@mokoconsulting.tech>
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ * Tools: windows_firewall_get (#57), windows_firewall_manage (#58)
+ */
+import { z } from 'zod';
+import { runPowerShell } from '../shell.js';
+export function registerFirewallTools(server) {
+    server.tool('windows_firewall_get', 'Get Windows Firewall status and list rules.', {
+        filter: z.string().optional().describe('Filter rules by name (substring)'),
+        direction: z.enum(['inbound', 'outbound', 'all']).default('all').describe('Rule direction'),
+        enabled_only: z.boolean().default(true).describe('Only show enabled rules'),
+        limit: z.number().default(30).describe('Max rules to return'),
+    }, async ({ filter, direction, enabled_only, limit }) => {
+        const dirFilter = direction === 'inbound' ? "| Where-Object { \\$_.Direction -eq 'Inbound' }"
+            : direction === 'outbound' ? "| Where-Object { \\$_.Direction -eq 'Outbound' }" : '';
+        const nameFilter = filter ? `| Where-Object { \\$_.DisplayName -like '*${filter.replace(/'/g, "''")}*' }` : '';
+        const enabledFilter = enabled_only ? "| Where-Object { \\$_.Enabled -eq 'True' }" : '';
+        const ps = `
+$profiles = Get-NetFirewallProfile -ErrorAction SilentlyContinue | ForEach-Object {
+  [PSCustomObject]@{ Name = $_.Name; Enabled = $_.Enabled; DefaultInbound = $_.DefaultInboundAction; DefaultOutbound = $_.DefaultOutboundAction }
+}
+
+$rules = Get-NetFirewallRule ${dirFilter} ${nameFilter} ${enabledFilter} -ErrorAction SilentlyContinue |
+  Select-Object -First ${limit} | ForEach-Object {
+    $port = ($_ | Get-NetFirewallPortFilter -ErrorAction SilentlyContinue)
+    [PSCustomObject]@{
+      Name = $_.DisplayName
+      Direction = $_.Direction.ToString()
+      Action = $_.Action.ToString()
+      Enabled = $_.Enabled.ToString()
+      Protocol = if ($port) { $port.Protocol } else { 'Any' }
+      Port = if ($port.LocalPort) { $port.LocalPort -join ',' } else { 'Any' }
+      Program = ($_ | Get-NetFirewallApplicationFilter -ErrorAction SilentlyContinue).Program
+    }
+  }
+
+[PSCustomObject]@{
+  Profiles = $profiles
+  Rules = $rules
+} | ConvertTo-Json -Depth 4 -Compress`;
+        const result = await runPowerShell(ps, { timeout: 30000 });
+        if (result.exitCode !== 0) {
+            return { content: [{ type: 'text', text: `Error: ${result.stderr}` }], isError: true };
+        }
+        const data = JSON.parse(result.stdout);
+        const lines = ['Firewall Profiles:'];
+        const profiles = Array.isArray(data.Profiles) ? data.Profiles : [data.Profiles];
+        for (const p of profiles.filter(Boolean)) {
+            lines.push(`  ${p.Name}: ${p.Enabled ? 'ON' : 'OFF'} (In: ${p.DefaultInbound}, Out: ${p.DefaultOutbound})`);
+        }
+        const rules = Array.isArray(data.Rules) ? data.Rules : data.Rules ? [data.Rules] : [];
+        if (rules.length > 0) {
+            lines.push('', `Rules (${rules.length}):`);
+            for (const r of rules) {
+                const dir = r.Direction === 'Inbound' ? 'IN ' : 'OUT';
+                const act = r.Action === 'Allow' ? 'ALLOW' : 'BLOCK';
+                lines.push(`  [${dir}] [${act}]  ${(r.Name || '').padEnd(35).slice(0, 35)}  ${r.Protocol}/${r.Port}`);
+            }
+        }
+        return { content: [{ type: 'text', text: lines.join('\n') }] };
+    });
+    server.tool('windows_firewall_manage', 'Create, enable, disable, or delete a firewall rule.', {
+        action: z.enum(['create', 'enable', 'disable', 'delete']).describe('Action'),
+        name: z.string().describe('Rule name'),
+        direction: z.enum(['inbound', 'outbound']).optional().describe('Direction (for create)'),
+        rule_action: z.enum(['allow', 'block']).optional().describe('Allow or block (for create)'),
+        port: z.string().optional().describe('Port number or range (for create)'),
+        protocol: z.enum(['TCP', 'UDP', 'Any']).optional().describe('Protocol (for create)'),
+        program: z.string().optional().describe('Program path (for create)'),
+    }, async ({ action, name, direction, rule_action, port, protocol, program }) => {
+        let ps;
+        switch (action) {
+            case 'create': {
+                if (!direction || !rule_action) {
+                    return { content: [{ type: 'text', text: 'Create requires direction and rule_action.' }], isError: true };
+                }
+                const dir = direction === 'inbound' ? 'Inbound' : 'Outbound';
+                const act = rule_action === 'allow' ? 'Allow' : 'Block';
+                const parts = [`New-NetFirewallRule -DisplayName '${name.replace(/'/g, "''")}' -Direction ${dir} -Action ${act}`];
+                if (port)
+                    parts.push(`-LocalPort ${port}`);
+                if (protocol && protocol !== 'Any')
+                    parts.push(`-Protocol ${protocol}`);
+                if (program)
+                    parts.push(`-Program '${program.replace(/'/g, "''")}'`);
+                parts.push('-ErrorAction Stop');
+                ps = `${parts.join(' ')} | Select-Object DisplayName,Direction,Action,Enabled | ConvertTo-Json -Compress`;
+                break;
+            }
+            case 'enable':
+                ps = `Enable-NetFirewallRule -DisplayName '${name.replace(/'/g, "''")}' -ErrorAction Stop; "Enabled: ${name}"`;
+                break;
+            case 'disable':
+                ps = `Disable-NetFirewallRule -DisplayName '${name.replace(/'/g, "''")}' -ErrorAction Stop; "Disabled: ${name}"`;
+                break;
+            case 'delete':
+                ps = `Remove-NetFirewallRule -DisplayName '${name.replace(/'/g, "''")}' -ErrorAction Stop; "Deleted: ${name}"`;
+                break;
+        }
+        const result = await runPowerShell(ps, { timeout: 15000 });
+        return {
+            content: [{ type: 'text', text: result.stdout || result.stderr }],
+            isError: result.exitCode !== 0,
+        };
+    });
+}
+//# sourceMappingURL=firewall.js.map

package/dist/tools/hosts.d.ts

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

package/dist/tools/hosts.js

@@ -0,0 +1,119 @@
+/* Copyright (C) 2026 Moko Consulting <hello@mokoconsulting.tech>
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ * Tool: windows_hosts_file (#51)
+ */
+import { z } from 'zod';
+import { readFile, writeFile, copyFile } from 'node:fs/promises';
+const HOSTS_PATH = 'C:\\Windows\\System32\\drivers\\etc\\hosts';
+export function registerHostsTools(server) {
+    server.tool('windows_hosts_file', 'Read and manage the Windows hosts file. List, add, remove, or toggle entries.', {
+        action: z.enum(['list', 'add', 'remove', 'enable', 'disable']).default('list').describe('Action'),
+        ip: z.string().optional().describe('IP address (for add)'),
+        hostname: z.string().optional().describe('Hostname (for add/remove/enable/disable)'),
+        comment: z.string().optional().describe('Comment (for add)'),
+    }, async ({ action, ip, hostname, comment }) => {
+        try {
+            const content = await readFile(HOSTS_PATH, 'utf-8');
+            const lines = content.split(/\r?\n/);
+            if (action === 'list') {
+                const entries = [];
+                lines.forEach((line, i) => {
+                    const trimmed = line.trim();
+                    if (!trimmed || trimmed.startsWith('#') && !trimmed.match(/^#\s*\d/)) {
+                        // Check if it's a commented-out entry
+                        const commented = trimmed.replace(/^#\s*/, '');
+                        const parts = commented.split(/\s+/);
+                        if (parts.length >= 2 && parts[0].match(/^\d+\.\d+\.\d+\.\d+$|^[a-f0-9:]+$/i)) {
+                            entries.push({
+                                line: i + 1,
+                                enabled: false,
+                                ip: parts[0],
+                                host: parts[1],
+                                comment: parts.slice(2).join(' ').replace(/^#\s*/, ''),
+                            });
+                        }
+                        return;
+                    }
+                    const parts = trimmed.split(/\s+/);
+                    if (parts.length >= 2 && parts[0].match(/^\d+\.\d+\.\d+\.\d+$|^[a-f0-9:]+$/i)) {
+                        entries.push({
+                            line: i + 1,
+                            enabled: true,
+                            ip: parts[0],
+                            host: parts[1],
+                            comment: parts.slice(2).join(' ').replace(/^#\s*/, ''),
+                        });
+                    }
+                });
+                const output = entries.map(e => {
+                    const status = e.enabled ? '[ON] ' : '[OFF]';
+                    return `${status}  ${e.ip.padEnd(18)}  ${e.host.padEnd(35)}  ${e.comment}`;
+                });
+                const header = `State  ${'IP'.padEnd(18)}  ${'Hostname'.padEnd(35)}  Comment`;
+                return {
+                    content: [{ type: 'text', text: `${HOSTS_PATH}\n${header}\n${'─'.repeat(80)}\n${output.join('\n')}\n\n${entries.length} entries` }],
+                };
+            }
+            // Backup before modification
+            await copyFile(HOSTS_PATH, HOSTS_PATH + '.bak');
+            if (action === 'add') {
+                if (!ip || !hostname) {
+                    return { content: [{ type: 'text', text: 'Add requires ip and hostname.' }], isError: true };
+                }
+                const entry = comment ? `${ip}\t${hostname}\t# ${comment}` : `${ip}\t${hostname}`;
+                const newContent = content.trimEnd() + '\n' + entry + '\n';
+                await writeFile(HOSTS_PATH, newContent, 'utf-8');
+                return { content: [{ type: 'text', text: `Added: ${ip} ${hostname}` }] };
+            }
+            if (action === 'remove') {
+                if (!hostname) {
+                    return { content: [{ type: 'text', text: 'Remove requires hostname.' }], isError: true };
+                }
+                const filtered = lines.filter(line => {
+                    const parts = line.trim().replace(/^#\s*/, '').split(/\s+/);
+                    return !(parts.length >= 2 && parts[1] === hostname);
+                });
+                await writeFile(HOSTS_PATH, filtered.join('\n'), 'utf-8');
+                return { content: [{ type: 'text', text: `Removed entries for: ${hostname}` }] };
+            }
+            if (action === 'disable') {
+                if (!hostname) {
+                    return { content: [{ type: 'text', text: 'Disable requires hostname.' }], isError: true };
+                }
+                const updated = lines.map(line => {
+                    const parts = line.trim().split(/\s+/);
+                    if (parts.length >= 2 && parts[1] === hostname && !line.trim().startsWith('#')) {
+                        return '# ' + line;
+                    }
+                    return line;
+                });
+                await writeFile(HOSTS_PATH, updated.join('\n'), 'utf-8');
+                return { content: [{ type: 'text', text: `Disabled: ${hostname}` }] };
+            }
+            if (action === 'enable') {
+                if (!hostname) {
+                    return { content: [{ type: 'text', text: 'Enable requires hostname.' }], isError: true };
+                }
+                const updated = lines.map(line => {
+                    const trimmed = line.trim();
+                    if (trimmed.startsWith('#')) {
+                        const uncommented = trimmed.replace(/^#\s*/, '');
+                        const parts = uncommented.split(/\s+/);
+                        if (parts.length >= 2 && parts[1] === hostname) {
+                            return uncommented;
+                        }
+                    }
+                    return line;
+                });
+                await writeFile(HOSTS_PATH, updated.join('\n'), 'utf-8');
+                return { content: [{ type: 'text', text: `Enabled: ${hostname}` }] };
+            }
+            return { content: [{ type: 'text', text: 'Unknown action.' }], isError: true };
+        }
+        catch (err) {
+            return { content: [{ type: 'text', text: `Error: ${err}. Hosts file modification may require elevation.` }], isError: true };
+        }
+    });
+}
+//# sourceMappingURL=hosts.js.map

package/dist/tools/maintenance.d.ts

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