@mokoconsulting/mcp-windows 3.0.0

package/src/tools/storage.ts

@@ -0,0 +1,141 @@
+/* Copyright (C) 2026 Moko Consulting <hello@mokoconsulting.tech>
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ * Tools: windows_disk_cleanup (#72), windows_symlink (#73)
+ */
+
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import { runPowerShell } from '../shell.js';
+
+export function registerStorageTools(server: McpServer): void {
+	server.tool(
+		'windows_disk_cleanup',
+		'Analyze disk usage and clean temp files, caches, and logs.',
+		{
+			action: z.enum(['analyze', 'clean']).default('analyze').describe('Analyze or clean'),
+			drive: z.string().default('C:').describe('Drive letter'),
+		},
+		async ({ action, drive }) => {
+			if (action === 'analyze') {
+				const ps = `
+$tempUser = [IO.Path]::GetTempPath()
+$tempWin = "$env:WINDIR\\Temp"
+$downloads = [Environment]::GetFolderPath('UserProfile') + '\\Downloads'
+
+function Get-FolderSize($path) {
+  if (Test-Path $path) {
+    $size = (Get-ChildItem $path -Recurse -File -ErrorAction SilentlyContinue | Measure-Object -Property Length -Sum).Sum
+    [math]::Round($size / 1MB, 1)
+  } else { 0 }
+}
+
+$disk = Get-CimInstance Win32_LogicalDisk -Filter "DeviceID='${drive.replace(/'/g, "''")}'"
+
+[PSCustomObject]@{
+  Drive = '${drive}'
+  TotalGB = [math]::Round($disk.Size / 1GB, 1)
+  FreeGB = [math]::Round($disk.FreeSpace / 1GB, 1)
+  UsedPct = [math]::Round(($disk.Size - $disk.FreeSpace) / $disk.Size * 100, 1)
+  TempUserMB = Get-FolderSize $tempUser
+  TempWindowsMB = Get-FolderSize $tempWin
+  DownloadsMB = Get-FolderSize $downloads
+  RecycleBinItems = (New-Object -ComObject Shell.Application).Namespace(10).Items().Count
+} | ConvertTo-Json -Compress`;
+
+				const result = await runPowerShell(ps, { timeout: 30000 });
+				if (result.exitCode !== 0) {
+					return { content: [{ type: 'text', text: `Error: ${result.stderr}` }], isError: true };
+				}
+				const d = JSON.parse(result.stdout);
+				return {
+					content: [{
+						type: 'text',
+						text: [
+							`${d.Drive} — ${d.FreeGB}/${d.TotalGB} GB free (${d.UsedPct}% used)`,
+							``,
+							`Cleanable:`,
+							`  User temp:     ${d.TempUserMB} MB`,
+							`  Windows temp:  ${d.TempWindowsMB} MB`,
+							`  Downloads:     ${d.DownloadsMB} MB`,
+							`  Recycle Bin:   ${d.RecycleBinItems} items`,
+						].join('\n'),
+					}],
+				};
+			}
+
+			const ps = `
+$before = (Get-CimInstance Win32_LogicalDisk -Filter "DeviceID='${drive.replace(/'/g, "''")}'").FreeSpace
+Remove-Item "$env:TEMP\\*" -Recurse -Force -ErrorAction SilentlyContinue
+Remove-Item "$env:WINDIR\\Temp\\*" -Recurse -Force -ErrorAction SilentlyContinue
+$after = (Get-CimInstance Win32_LogicalDisk -Filter "DeviceID='${drive.replace(/'/g, "''")}'").FreeSpace
+$freed = [math]::Round(($after - $before) / 1MB, 1)
+"Cleaned temp files. Freed: $freed MB"`;
+
+			const result = await runPowerShell(ps, { timeout: 30000 });
+			return { content: [{ type: 'text', text: result.stdout || result.stderr }] };
+		},
+	);
+
+	server.tool(
+		'windows_symlink',
+		'Create and manage symbolic links, hard links, and directory junctions.',
+		{
+			action: z.enum(['create', 'list', 'resolve', 'remove']).default('list').describe('Action'),
+			target: z.string().optional().describe('Target path (what the link points to)'),
+			link: z.string().optional().describe('Link path (the symlink itself)'),
+			type: z.enum(['symlink', 'junction', 'hardlink']).default('symlink').describe('Link type (for create)'),
+			path: z.string().optional().describe('Directory to list symlinks in (for list)'),
+		},
+		async ({ action, target, link, type, path }) => {
+			switch (action) {
+				case 'create': {
+					if (!target || !link) {
+						return { content: [{ type: 'text', text: 'create requires target and link.' }], isError: true };
+					}
+					let cmd: string;
+					if (type === 'junction') {
+						cmd = `cmd /c mklink /J "${link}" "${target}"`;
+					} else if (type === 'hardlink') {
+						cmd = `cmd /c mklink /H "${link}" "${target}"`;
+					} else {
+						cmd = `cmd /c mklink ${target.includes('.') ? '' : '/D'} "${link}" "${target}"`;
+					}
+					const ps = `& { ${cmd} } 2>&1`;
+					const result = await runPowerShell(ps, { timeout: 10000 });
+					return { content: [{ type: 'text', text: result.stdout || result.stderr }] };
+				}
+				case 'list': {
+					const dir = path || '.';
+					const ps = `
+Get-ChildItem -Path '${dir.replace(/'/g, "''")}' -Force -ErrorAction Stop | Where-Object { $_.Attributes -band [IO.FileAttributes]::ReparsePoint } | ForEach-Object {
+  [PSCustomObject]@{
+    Name = $_.Name
+    Target = $_.Target
+    Type = if ($_.PSIsContainer) { 'Directory' } else { 'File' }
+    LinkType = $_.LinkType
+  }
+} | ConvertTo-Json -Depth 3 -Compress`;
+					const result = await runPowerShell(ps, { timeout: 10000 });
+					if (!result.stdout) return { content: [{ type: 'text', text: 'No symlinks found.' }] };
+					const links = Array.isArray(JSON.parse(result.stdout)) ? JSON.parse(result.stdout) : [JSON.parse(result.stdout)];
+					const lines = links.map((l: { Name: string; Target: string; LinkType: string }) =>
+						`  ${(l.LinkType || 'Link').padEnd(12)} ${l.Name.padEnd(30)} -> ${l.Target}`);
+					return { content: [{ type: 'text', text: `Symlinks in ${dir}:\n${lines.join('\n')}` }] };
+				}
+				case 'resolve': {
+					if (!link) return { content: [{ type: 'text', text: 'resolve requires link path.' }], isError: true };
+					const ps = `(Get-Item '${link.replace(/'/g, "''")}' -Force).Target`;
+					const result = await runPowerShell(ps, { timeout: 5000 });
+					return { content: [{ type: 'text', text: `${link} -> ${result.stdout || '(not a symlink)'}` }] };
+				}
+				case 'remove': {
+					if (!link) return { content: [{ type: 'text', text: 'remove requires link path.' }], isError: true };
+					const ps = `Remove-Item '${link.replace(/'/g, "''")}' -Force -ErrorAction Stop; "Removed: ${link}"`;
+					const result = await runPowerShell(ps, { timeout: 5000 });
+					return { content: [{ type: 'text', text: result.stdout || result.stderr }] };
+				}
+			}
+		},
+	);
+}

package/src/tools/system.ts

@@ -0,0 +1,99 @@
+/* Copyright (C) 2026 Moko Consulting <hello@mokoconsulting.tech>
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ * Tool: windows_system_info (#18)
+ */
+
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { runPowerShell } from '../shell.js';
+
+export function registerSystemTools(server: McpServer): void {
+	server.tool(
+		'windows_system_info',
+		'Get comprehensive system information: OS, CPU, RAM, disk, network, uptime.',
+		{},
+		async () => {
+			const ps = `
+$os = Get-CimInstance Win32_OperatingSystem
+$cpu = Get-CimInstance Win32_Processor | Select-Object -First 1
+$cs = Get-CimInstance Win32_ComputerSystem
+$disks = Get-CimInstance Win32_LogicalDisk -Filter "DriveType=3" | ForEach-Object {
+  [PSCustomObject]@{
+    Drive = $_.DeviceID
+    Label = $_.VolumeName
+    FileSystem = $_.FileSystem
+    TotalGB = [math]::Round($_.Size / 1GB, 1)
+    FreeGB = [math]::Round($_.FreeSpace / 1GB, 1)
+    UsedPct = if ($_.Size -gt 0) { [math]::Round(($_.Size - $_.FreeSpace) / $_.Size * 100, 1) } else { 0 }
+  }
+}
+$adapters = Get-NetAdapter -Physical -ErrorAction SilentlyContinue | Where-Object { $_.Status -eq 'Up' } | ForEach-Object {
+  $ip = (Get-NetIPAddress -InterfaceIndex $_.ifIndex -AddressFamily IPv4 -ErrorAction SilentlyContinue).IPAddress
+  [PSCustomObject]@{
+    Name = $_.Name
+    Speed = $_.LinkSpeed
+    IP = $ip
+    MAC = $_.MacAddress
+  }
+}
+$uptime = (Get-Date) - $os.LastBootUpTime
+
+[PSCustomObject]@{
+  OS = "$($os.Caption) $($os.Version) Build $($os.BuildNumber)"
+  Edition = $os.OperatingSystemSKU
+  Architecture = $os.OSArchitecture
+  Hostname = $env:COMPUTERNAME
+  Username = $env:USERNAME
+  Domain = $cs.Domain
+  CPU = "$($cpu.Name)"
+  CPUCores = "$($cpu.NumberOfCores) cores / $($cpu.NumberOfLogicalProcessors) threads"
+  CPUUsage = "$([math]::Round($cpu.LoadPercentage, 0))%"
+  RAMTotalGB = [math]::Round($cs.TotalPhysicalMemory / 1GB, 1)
+  RAMAvailGB = [math]::Round($os.FreePhysicalMemory / 1MB, 1)
+  RAMUsedPct = [math]::Round(($cs.TotalPhysicalMemory - $os.FreePhysicalMemory * 1KB) / $cs.TotalPhysicalMemory * 100, 1)
+  Disks = $disks
+  Network = $adapters
+  Uptime = "$($uptime.Days)d $($uptime.Hours)h $($uptime.Minutes)m"
+} | ConvertTo-Json -Depth 4 -Compress`;
+
+			const result = await runPowerShell(ps, { timeout: 45000 });
+			if (result.exitCode !== 0) {
+				return { content: [{ type: 'text', text: `Error: ${result.stderr}` }], isError: true };
+			}
+
+			const info = JSON.parse(result.stdout);
+			const diskLines = (Array.isArray(info.Disks) ? info.Disks : [info.Disks])
+				.filter(Boolean)
+				.map((d: { Drive: string; Label: string; TotalGB: number; FreeGB: number; UsedPct: number }) =>
+					`  ${d.Drive} ${d.Label || ''} — ${d.FreeGB}/${d.TotalGB} GB free (${d.UsedPct}% used)`,
+				);
+			const netLines = (Array.isArray(info.Network) ? info.Network : [info.Network])
+				.filter(Boolean)
+				.map((n: { Name: string; IP: string; Speed: string }) =>
+					`  ${n.Name} — ${n.IP || 'no IP'} (${n.Speed})`,
+				);
+
+			const text = [
+				`OS: ${info.OS}`,
+				`Architecture: ${info.Architecture}`,
+				`Host: ${info.Hostname} (${info.Domain})`,
+				`User: ${info.Username}`,
+				`Uptime: ${info.Uptime}`,
+				``,
+				`CPU: ${info.CPU}`,
+				`Cores: ${info.CPUCores}`,
+				`CPU Usage: ${info.CPUUsage}`,
+				``,
+				`RAM: ${info.RAMAvailGB}/${info.RAMTotalGB} GB available (${info.RAMUsedPct}% used)`,
+				``,
+				`Disks:`,
+				...diskLines,
+				``,
+				`Network:`,
+				...netLines,
+			].join('\n');
+
+			return { content: [{ type: 'text', text }] };
+		},
+	);
+}

package/src/tools/system_mgmt.ts

@@ -0,0 +1,190 @@
+/* Copyright (C) 2026 Moko Consulting <hello@mokoconsulting.tech>
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ * Tools: windows_timezone (#74), windows_features (#75),
+ *        windows_smb_shares (#76), windows_dns_cache (#77)
+ */
+
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import { runPowerShell } from '../shell.js';
+
+export function registerSystemMgmtTools(server: McpServer): void {
+	server.tool(
+		'windows_timezone',
+		'Get or set system timezone. List available timezones or sync time.',
+		{
+			action: z.enum(['get', 'list', 'set', 'sync']).default('get').describe('Action'),
+			timezone: z.string().optional().describe('Timezone ID (for set, e.g. "Eastern Standard Time")'),
+			filter: z.string().optional().describe('Filter timezone list'),
+		},
+		async ({ action, timezone, filter }) => {
+			switch (action) {
+				case 'get': {
+					const ps = `
+$tz = Get-TimeZone
+[PSCustomObject]@{
+  Id = $tz.Id
+  DisplayName = $tz.DisplayName
+  UTCOffset = $tz.BaseUtcOffset.ToString()
+  DST = $tz.SupportsDaylightSavingTime
+  DSTActive = (Get-Date).IsDaylightSavingTime()
+  CurrentTime = (Get-Date).ToString('yyyy-MM-dd HH:mm:ss')
+  UTCTime = (Get-Date).ToUniversalTime().ToString('yyyy-MM-dd HH:mm:ss')
+} | 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 tz = JSON.parse(result.stdout);
+					return {
+						content: [{
+							type: 'text',
+							text: `Timezone: ${tz.Id}\n${tz.DisplayName}\nUTC Offset: ${tz.UTCOffset}${tz.DSTActive ? ' (DST active)' : ''}\nLocal: ${tz.CurrentTime}\nUTC: ${tz.UTCTime}`,
+						}],
+					};
+				}
+				case 'list': {
+					const filterClause = filter ? `| Where-Object { $_.Id -like '*${filter.replace(/'/g, "''")}*' -or $_.DisplayName -like '*${filter.replace(/'/g, "''")}*' }` : '';
+					const ps = `Get-TimeZone -ListAvailable ${filterClause} | ForEach-Object { "$($_.BaseUtcOffset.ToString().PadRight(9))  $($_.Id)" }`;
+					const result = await runPowerShell(ps, { timeout: 10000 });
+					return { content: [{ type: 'text', text: result.stdout || 'No timezones found.' }] };
+				}
+				case 'set': {
+					if (!timezone) return { content: [{ type: 'text', text: 'set requires timezone.' }], isError: true };
+					const ps = `Set-TimeZone -Id '${timezone.replace(/'/g, "''")}' -ErrorAction Stop; "Timezone set to: ${timezone}"`;
+					const result = await runPowerShell(ps, { timeout: 10000 });
+					return { content: [{ type: 'text', text: result.stdout || result.stderr }], isError: result.exitCode !== 0 };
+				}
+				case 'sync': {
+					const ps = `w32tm /resync /force 2>&1; "Time sync requested"`;
+					const result = await runPowerShell(ps, { timeout: 15000 });
+					return { content: [{ type: 'text', text: result.stdout || result.stderr }] };
+				}
+			}
+		},
+	);
+
+	server.tool(
+		'windows_features',
+		'List, enable, or disable Windows optional features (WSL, Hyper-V, Sandbox, etc.).',
+		{
+			action: z.enum(['list', 'enable', 'disable']).default('list').describe('Action'),
+			name: z.string().optional().describe('Feature name (for enable/disable)'),
+			filter: z.string().optional().describe('Filter by name (for list)'),
+		},
+		async ({ action, name, filter }) => {
+			if (action === 'list') {
+				const filterClause = filter ? `| Where-Object { $_.FeatureName -like '*${filter.replace(/'/g, "''")}*' }` : '';
+				const ps = `
+try {
+  Get-WindowsOptionalFeature -Online -ErrorAction Stop ${filterClause} | Select-Object FeatureName,State | Sort-Object FeatureName | ConvertTo-Json -Depth 3 -Compress
+} catch {
+  if ($_.Exception.Message -match 'elevation') { Write-Output 'NEEDS_ELEVATION' }
+  else { throw }
+}`;
+				const result = await runPowerShell(ps, { timeout: 30000 });
+				if (result.stdout?.trim() === 'NEEDS_ELEVATION') {
+					return { content: [{ type: 'text', text: 'Windows Optional Features requires elevation (run as Administrator).' }] };
+				}
+				if (result.exitCode !== 0) return { content: [{ type: 'text', text: `Error: ${result.stderr}` }], isError: true };
+				if (!result.stdout) return { content: [{ type: 'text', text: 'No features found.' }] };
+				const features = Array.isArray(JSON.parse(result.stdout)) ? JSON.parse(result.stdout) : [JSON.parse(result.stdout)];
+				const lines = features.map((f: { FeatureName: string; State: number }) => {
+					const state = f.State === 2 ? '[ON] ' : '[OFF]';
+					return `${state} ${f.FeatureName}`;
+				});
+				return { content: [{ type: 'text', text: `${lines.join('\n')}\n\n${features.length} features` }] };
+			}
+
+			if (!name) return { content: [{ type: 'text', text: `${action} requires name.` }], isError: true };
+			const cmd = action === 'enable'
+				? `Enable-WindowsOptionalFeature -Online -FeatureName '${name.replace(/'/g, "''")}' -NoRestart -ErrorAction Stop`
+				: `Disable-WindowsOptionalFeature -Online -FeatureName '${name.replace(/'/g, "''")}' -NoRestart -ErrorAction Stop`;
+			const ps = `${cmd} | Select-Object RestartNeeded | ConvertTo-Json -Compress`;
+			const result = await runPowerShell(ps, { timeout: 60000 });
+			if (result.exitCode !== 0) return { content: [{ type: 'text', text: `Error: ${result.stderr}` }], isError: true };
+			const info = JSON.parse(result.stdout);
+			return { content: [{ type: 'text', text: `${name}: ${action}d${info.RestartNeeded ? ' (restart required)' : ''}` }] };
+		},
+	);
+
+	server.tool(
+		'windows_smb_shares',
+		'List local shares, mapped drives, or map/unmap network drives.',
+		{
+			action: z.enum(['list_shares', 'list_mapped', 'map', 'unmap']).default('list_shares').describe('Action'),
+			letter: z.string().optional().describe('Drive letter (for map/unmap, e.g. "Z:")'),
+			unc_path: z.string().optional().describe('UNC path (for map, e.g. "\\\\\\\\server\\\\share")'),
+		},
+		async ({ action, letter, unc_path }) => {
+			switch (action) {
+				case 'list_shares': {
+					const ps = `Get-SmbShare -ErrorAction Stop | Select-Object Name,Path,Description | 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 shares.' }] };
+					const shares = Array.isArray(JSON.parse(result.stdout)) ? JSON.parse(result.stdout) : [JSON.parse(result.stdout)];
+					const lines = shares.map((s: { Name: string; Path: string; Description: string }) =>
+						`  ${s.Name.padEnd(20)} ${(s.Path || '').padEnd(30)} ${s.Description || ''}`);
+					return { content: [{ type: 'text', text: `Local shares:\n${lines.join('\n')}` }] };
+				}
+				case 'list_mapped': {
+					const ps = `Get-PSDrive -PSProvider FileSystem | Where-Object { $_.DisplayRoot } | ForEach-Object { "$($_.Name):  $($_.DisplayRoot)" }`;
+					const result = await runPowerShell(ps, { timeout: 10000 });
+					return { content: [{ type: 'text', text: result.stdout || 'No mapped drives.' }] };
+				}
+				case 'map': {
+					if (!letter || !unc_path) return { content: [{ type: 'text', text: 'map requires letter and unc_path.' }], isError: true };
+					const ps = `net use ${letter} "${unc_path}" /persistent:yes 2>&1`;
+					const result = await runPowerShell(ps, { timeout: 15000 });
+					return { content: [{ type: 'text', text: result.stdout || result.stderr }] };
+				}
+				case 'unmap': {
+					if (!letter) return { content: [{ type: 'text', text: 'unmap requires letter.' }], isError: true };
+					const ps = `net use ${letter} /delete /yes 2>&1`;
+					const result = await runPowerShell(ps, { timeout: 10000 });
+					return { content: [{ type: 'text', text: result.stdout || result.stderr }] };
+				}
+			}
+		},
+	);
+
+	server.tool(
+		'windows_dns_cache',
+		'View, filter, or clear the DNS resolver cache. Also resolves domain names.',
+		{
+			action: z.enum(['list', 'clear', 'resolve']).default('list').describe('Action'),
+			filter: z.string().optional().describe('Filter by domain (for list)'),
+			domain: z.string().optional().describe('Domain to resolve (for resolve)'),
+			limit: z.number().default(30).describe('Max entries (for list)'),
+		},
+		async ({ action, filter, domain, limit }) => {
+			switch (action) {
+				case 'list': {
+					const filterClause = filter ? `| Where-Object { $_.Entry -like '*${filter.replace(/'/g, "''")}*' }` : '';
+					const ps = `Get-DnsClientCache ${filterClause} -ErrorAction SilentlyContinue | Select-Object -First ${limit} Entry,RecordName,RecordType,Data,TimeToLive | ConvertTo-Json -Depth 3 -Compress`;
+					const result = await runPowerShell(ps, { timeout: 10000 });
+					if (!result.stdout) return { content: [{ type: 'text', text: 'DNS cache is empty.' }] };
+					const entries = Array.isArray(JSON.parse(result.stdout)) ? JSON.parse(result.stdout) : [JSON.parse(result.stdout)];
+					const lines = entries.map((e: { Entry: string; RecordType: number; Data: string; TimeToLive: number }) =>
+						`  ${(e.Entry || '').padEnd(40).slice(0, 40)}  ${String(e.RecordType).padEnd(5)}  ${String(e.TimeToLive).padStart(6)}s  ${e.Data || ''}`);
+					return { content: [{ type: 'text', text: `DNS Cache (${entries.length} entries):\n${lines.join('\n')}` }] };
+				}
+				case 'clear': {
+					const ps = `Clear-DnsClientCache; "DNS cache cleared"`;
+					const result = await runPowerShell(ps, { timeout: 5000 });
+					return { content: [{ type: 'text', text: result.stdout || result.stderr }] };
+				}
+				case 'resolve': {
+					if (!domain) return { content: [{ type: 'text', text: 'resolve requires domain.' }], isError: true };
+					const ps = `Resolve-DnsName '${domain.replace(/'/g, "''")}' -ErrorAction Stop | Select-Object Name,Type,IPAddress,NameHost | 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 records = Array.isArray(JSON.parse(result.stdout)) ? JSON.parse(result.stdout) : [JSON.parse(result.stdout)];
+					const lines = records.map((r: { Name: string; Type: number; IPAddress: string; NameHost: string }) =>
+						`  ${r.Name}  ${r.IPAddress || r.NameHost || ''}`);
+					return { content: [{ type: 'text', text: `${domain}:\n${lines.join('\n')}` }] };
+				}
+			}
+		},
+	);
+}

package/src/tools/terminal.ts

@@ -0,0 +1,117 @@
+/* Copyright (C) 2026 Moko Consulting <hello@mokoconsulting.tech>
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ * Tool: windows_terminal_session — Persistent interactive terminals (#35)
+ */
+
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import {
+	startSession,
+	sendToSession,
+	readSessionOutput,
+	listSessions,
+	terminateSession,
+} from '../shell.js';
+
+export function registerTerminalTools(server: McpServer): void {
+	server.tool(
+		'windows_terminal_start',
+		'Start a persistent interactive terminal session (PowerShell, cmd, bash, python, node, wsl).',
+		{
+			shell: z.enum(['pwsh', 'cmd', 'bash', 'python', 'node', 'wsl']).default('pwsh').describe('Shell type'),
+		},
+		async ({ shell }) => {
+			const session = startSession(shell);
+			// Give the shell a moment to start and produce initial output
+			await new Promise(resolve => setTimeout(resolve, 500));
+			return {
+				content: [{
+					type: 'text',
+					text: `Session started: PID ${session.pid} (${session.shell})\nUse windows_terminal_send to send commands, windows_terminal_read to read output.`,
+				}],
+			};
+		},
+	);
+
+	server.tool(
+		'windows_terminal_send',
+		'Send input to a running interactive terminal session.',
+		{
+			pid: z.number().describe('Session PID'),
+			input: z.string().describe('Text to send to the session'),
+		},
+		async ({ pid, input }) => {
+			try {
+				sendToSession(pid, input);
+				// Wait for output to arrive
+				await new Promise(resolve => setTimeout(resolve, 1000));
+				const lines = readSessionOutput(pid, -30);
+				return {
+					content: [{
+						type: 'text',
+						text: lines.join('\n') || '(no output yet)',
+					}],
+				};
+			} catch (err) {
+				return { content: [{ type: 'text', text: `Error: ${err}` }], isError: true };
+			}
+		},
+	);
+
+	server.tool(
+		'windows_terminal_read',
+		'Read output from a terminal session with pagination. Use negative offset to read from the end.',
+		{
+			pid: z.number().describe('Session PID'),
+			offset: z.number().default(0).describe('Line offset (negative = from end)'),
+			length: z.number().optional().describe('Number of lines to return'),
+		},
+		async ({ pid, offset, length }) => {
+			try {
+				const lines = readSessionOutput(pid, offset, length);
+				return {
+					content: [{
+						type: 'text',
+						text: lines.join('\n') || '(no output)',
+					}],
+				};
+			} catch (err) {
+				return { content: [{ type: 'text', text: `Error: ${err}` }], isError: true };
+			}
+		},
+	);
+
+	server.tool(
+		'windows_terminal_list',
+		'List all active terminal sessions.',
+		{},
+		async () => {
+			const sessions = listSessions();
+			if (sessions.length === 0) {
+				return { content: [{ type: 'text', text: 'No active sessions.' }] };
+			}
+			const lines = sessions.map(s =>
+				`PID ${s.pid} — ${s.shell} — ${s.running ? 'running' : 'ended'} — ${s.lines} lines — started ${s.startedAt}`,
+			);
+			return { content: [{ type: 'text', text: lines.join('\n') }] };
+		},
+	);
+
+	server.tool(
+		'windows_terminal_kill',
+		'Terminate a terminal session by PID.',
+		{
+			pid: z.number().describe('Session PID to terminate'),
+		},
+		async ({ pid }) => {
+			const killed = terminateSession(pid);
+			return {
+				content: [{
+					type: 'text',
+					text: killed ? `Session ${pid} terminated.` : `No session with PID ${pid}.`,
+				}],
+			};
+		},
+	);
+}