@mokoconsulting/mcp-windows 3.0.0

package/src/tools/drives.ts

@@ -0,0 +1,124 @@
+/* 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 { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import { runPowerShell } from '../shell.js';
+
+export function registerDriveTools(server: McpServer): void {
+	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: { Drive: string; Label: string; Type: string; FileSystem: string; TotalGB: number; FreeGB: number; UsedPct: number }) => {
+				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: string;
+			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: string;
+			if (type === 'name') {
+				text = results.map((r: { Path: string; Size: number; Modified: string }) =>
+					`${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: { Path: string; Line: number; Match: string }) =>
+					`${r.Path}:${r.Line}: ${r.Match}`,
+				).join('\n');
+			}
+
+			return { content: [{ type: 'text', text: `${results.length} result(s):\n\n${text}` }] };
+		},
+	);
+}
+
+function makeBar(pct: number): string {
+	const filled = Math.round(pct / 10);
+	return '[' + '█'.repeat(filled) + '░'.repeat(10 - filled) + ']';
+}

package/src/tools/environment.ts

@@ -0,0 +1,146 @@
+/* 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 { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import { runPowerShell } from '../shell.js';
+
+export function registerEnvironmentTools(server: McpServer): void {
+	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: string) => `  ${p}`).join('\n')}\n\nUser PATH (${userPaths.length} entries):\n${userPaths.map((p: string) => `  ${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: string[] = [];
+
+			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: { Name: string; Value: string }) =>
+					`  ${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: string;
+
+			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,
+			};
+		},
+	);
+}

package/src/tools/execute.ts

@@ -0,0 +1,35 @@
+/* Copyright (C) 2026 Moko Consulting <hello@mokoconsulting.tech>
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ * Tool: windows_execute — Execute shell commands (#1)
+ */
+
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import { runShell } from '../shell.js';
+
+export function registerExecuteTools(server: McpServer): void {
+	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: string[] = [];
+
+			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,
+			};
+		},
+	);
+}

package/src/tools/filesystem.ts

@@ -0,0 +1,273 @@
+/* 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 { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+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: McpServer): void {
+
+	// ── 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: Record<string, string> = {
+						'.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' as const,
+							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: number;
+				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: string;
+				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.',
+				}],
+			};
+		},
+	);
+}