@mokoconsulting/mcp-windows 3.0.0

package/dist/tools/startup.js

@@ -0,0 +1,159 @@
+/* Copyright (C) 2026 Moko Consulting <hello@mokoconsulting.tech>
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ * Tools: windows_startup_list (#33), windows_startup_manage (#34)
+ */
+import { z } from 'zod';
+import { runPowerShell } from '../shell.js';
+export function registerStartupTools(server) {
+    server.tool('windows_startup_list', 'List all startup items from registry (Run/RunOnce), startup folder, and scheduled logon tasks.', {}, async () => {
+        const ps = `
+$items = [System.Collections.Generic.List[PSObject]]::new()
+
+# Registry: HKCU Run
+$regPaths = @(
+  @{ Path = 'HKCU:\\Software\\Microsoft\\Windows\\CurrentVersion\\Run'; Scope = 'User'; Source = 'Registry Run' }
+  @{ Path = 'HKCU:\\Software\\Microsoft\\Windows\\CurrentVersion\\RunOnce'; Scope = 'User'; Source = 'Registry RunOnce' }
+  @{ Path = 'HKLM:\\Software\\Microsoft\\Windows\\CurrentVersion\\Run'; Scope = 'System'; Source = 'Registry Run' }
+  @{ Path = 'HKLM:\\Software\\Microsoft\\Windows\\CurrentVersion\\RunOnce'; Scope = 'System'; Source = 'Registry RunOnce' }
+)
+
+foreach ($rp in $regPaths) {
+  if (Test-Path $rp.Path) {
+    $props = Get-ItemProperty -Path $rp.Path -ErrorAction SilentlyContinue
+    if ($props) {
+      $props.PSObject.Properties | Where-Object { $_.Name -notlike 'PS*' } | ForEach-Object {
+        $items.Add([PSCustomObject]@{
+          Name = $_.Name
+          Command = $_.Value
+          Source = $rp.Source
+          Scope = $rp.Scope
+          Enabled = $true
+        })
+      }
+    }
+  }
+}
+
+# Startup folder
+$userStartup = [Environment]::GetFolderPath('Startup')
+$commonStartup = [Environment]::GetFolderPath('CommonStartup')
+foreach ($folder in @(@{Path=$userStartup;Scope='User'}, @{Path=$commonStartup;Scope='System'})) {
+  if (Test-Path $folder.Path) {
+    Get-ChildItem -Path $folder.Path -File -ErrorAction SilentlyContinue | ForEach-Object {
+      $items.Add([PSCustomObject]@{
+        Name = $_.BaseName
+        Command = $_.FullName
+        Source = 'Startup Folder'
+        Scope = $folder.Scope
+        Enabled = $true
+      })
+    }
+  }
+}
+
+# Scheduled tasks at logon
+Get-ScheduledTask -ErrorAction SilentlyContinue | Where-Object {
+  $_.Triggers | Where-Object { $_ -is [CimInstance] -and $_.CimClass.CimClassName -eq 'MSFT_TaskLogonTrigger' }
+} | ForEach-Object {
+  $items.Add([PSCustomObject]@{
+    Name = $_.TaskName
+    Command = ($_.Actions | ForEach-Object { $_.Execute }) -join ' '
+    Source = 'Task Scheduler (Logon)'
+    Scope = 'System'
+    Enabled = $_.State -eq 'Ready'
+  })
+}
+
+$items | ConvertTo-Json -Depth 3 -Compress`;
+        const result = await runPowerShell(ps, { timeout: 20000 });
+        if (result.exitCode !== 0) {
+            return { content: [{ type: 'text', text: `Error: ${result.stderr}` }], isError: true };
+        }
+        if (!result.stdout) {
+            return { content: [{ type: 'text', text: 'No startup items found.' }] };
+        }
+        const items = Array.isArray(JSON.parse(result.stdout)) ? JSON.parse(result.stdout) : [JSON.parse(result.stdout)];
+        const lines = items.map((i) => {
+            const status = i.Enabled ? '[ON] ' : '[OFF]';
+            return `${status}  ${i.Scope.padEnd(6)}  ${i.Source.padEnd(24)}  ${i.Name.padEnd(30).slice(0, 30)}  ${(i.Command || '').slice(0, 50)}`;
+        });
+        const header = `State  ${'Scope'.padEnd(6)}  ${'Source'.padEnd(24)}  ${'Name'.padEnd(30)}  Command`;
+        return {
+            content: [{ type: 'text', text: `${header}\n${'─'.repeat(110)}\n${lines.join('\n')}\n\n${items.length} startup items` }],
+        };
+    });
+    server.tool('windows_startup_manage', 'Add, remove, enable, or disable a startup item.', {
+        action: z.enum(['add', 'remove', 'enable', 'disable']).describe('Action'),
+        name: z.string().describe('Startup item name'),
+        command: z.string().optional().describe('Command to run at startup (for add)'),
+        location: z.enum(['registry', 'startup_folder']).default('registry').describe('Where to add (for add)'),
+    }, async ({ action, name, command, location }) => {
+        let ps;
+        switch (action) {
+            case 'add':
+                if (!command) {
+                    return { content: [{ type: 'text', text: 'Add requires a command.' }], isError: true };
+                }
+                if (location === 'startup_folder') {
+                    ps = `
+$startupPath = [Environment]::GetFolderPath('Startup')
+$shortcutPath = Join-Path $startupPath '${name.replace(/'/g, "''")}.lnk'
+$ws = New-Object -ComObject WScript.Shell
+$sc = $ws.CreateShortcut($shortcutPath)
+$sc.TargetPath = '${command.replace(/'/g, "''")}'
+$sc.Save()
+"Added startup shortcut: $shortcutPath"`;
+                }
+                else {
+                    ps = `
+Set-ItemProperty -Path 'HKCU:\\Software\\Microsoft\\Windows\\CurrentVersion\\Run' -Name '${name.replace(/'/g, "''")}' -Value '${command.replace(/'/g, "''")}' -ErrorAction Stop
+"Added to HKCU Run: ${name}"`;
+                }
+                break;
+            case 'remove':
+                ps = `
+$removed = $false
+# Try registry
+$regPath = 'HKCU:\\Software\\Microsoft\\Windows\\CurrentVersion\\Run'
+if ((Get-ItemProperty -Path $regPath -Name '${name.replace(/'/g, "''")}' -ErrorAction SilentlyContinue)) {
+  Remove-ItemProperty -Path $regPath -Name '${name.replace(/'/g, "''")}' -ErrorAction Stop
+  $removed = $true
+}
+# Try startup folder
+$startupPath = [Environment]::GetFolderPath('Startup')
+$lnk = Join-Path $startupPath '${name.replace(/'/g, "''")}.lnk'
+if (Test-Path $lnk) { Remove-Item $lnk -Force; $removed = $true }
+if ($removed) { "Removed: ${name}" } else { "Not found: ${name}" }`;
+                break;
+            case 'disable':
+                ps = `
+$regPath = 'HKCU:\\Software\\Microsoft\\Windows\\CurrentVersion\\Run'
+$val = (Get-ItemProperty -Path $regPath -Name '${name.replace(/'/g, "''")}' -ErrorAction SilentlyContinue).'${name.replace(/'/g, "''")}'
+if ($val) {
+  Remove-ItemProperty -Path $regPath -Name '${name.replace(/'/g, "''")}' -ErrorAction Stop
+  $disabledPath = 'HKCU:\\Software\\Microsoft\\Windows\\CurrentVersion\\Run_Disabled'
+  if (-not (Test-Path $disabledPath)) { New-Item -Path $disabledPath -Force | Out-Null }
+  Set-ItemProperty -Path $disabledPath -Name '${name.replace(/'/g, "''")}' -Value $val
+  "Disabled: ${name}"
+} else { "Not found in registry Run: ${name}" }`;
+                break;
+            case 'enable':
+                ps = `
+$disabledPath = 'HKCU:\\Software\\Microsoft\\Windows\\CurrentVersion\\Run_Disabled'
+$val = (Get-ItemProperty -Path $disabledPath -Name '${name.replace(/'/g, "''")}' -ErrorAction SilentlyContinue).'${name.replace(/'/g, "''")}'
+if ($val) {
+  Set-ItemProperty -Path 'HKCU:\\Software\\Microsoft\\Windows\\CurrentVersion\\Run' -Name '${name.replace(/'/g, "''")}' -Value $val
+  Remove-ItemProperty -Path $disabledPath -Name '${name.replace(/'/g, "''")}' -ErrorAction SilentlyContinue
+  "Enabled: ${name}"
+} else { "Not found in disabled items: ${name}" }`;
+                break;
+        }
+        const result = await runPowerShell(ps, { timeout: 10000 });
+        return {
+            content: [{ type: 'text', text: result.stdout || result.stderr }],
+            isError: result.exitCode !== 0,
+        };
+    });
+}
+//# sourceMappingURL=startup.js.map

package/dist/tools/storage.d.ts

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

package/dist/tools/storage.js

@@ -0,0 +1,129 @@
+/* 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 { z } from 'zod';
+import { runPowerShell } from '../shell.js';
+export function registerStorageTools(server) {
+    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;
+                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) => `  ${(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 }] };
+            }
+        }
+    });
+}
+//# sourceMappingURL=storage.js.map

package/dist/tools/system.d.ts

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

package/dist/tools/system.js

@@ -0,0 +1,84 @@
+/* Copyright (C) 2026 Moko Consulting <hello@mokoconsulting.tech>
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ * Tool: windows_system_info (#18)
+ */
+import { runPowerShell } from '../shell.js';
+export function registerSystemTools(server) {
+    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) => `  ${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) => `  ${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 }] };
+    });
+}
+//# sourceMappingURL=system.js.map

package/dist/tools/system_mgmt.d.ts

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

package/dist/tools/system_mgmt.js

@@ -0,0 +1,174 @@
+/* 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 { z } from 'zod';
+import { runPowerShell } from '../shell.js';
+export function registerSystemMgmtTools(server) {
+    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) => {
+                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) => `  ${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) => `  ${(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) => `  ${r.Name}  ${r.IPAddress || r.NameHost || ''}`);
+                return { content: [{ type: 'text', text: `${domain}:\n${lines.join('\n')}` }] };
+            }
+        }
+    });
+}
+//# sourceMappingURL=system_mgmt.js.map

package/dist/tools/terminal.d.ts

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

package/dist/tools/terminal.js

@@ -0,0 +1,80 @@
+/* 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 { z } from 'zod';
+import { startSession, sendToSession, readSessionOutput, listSessions, terminateSession, } from '../shell.js';
+export function registerTerminalTools(server) {
+    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}.`,
+                }],
+        };
+    });
+}
+//# sourceMappingURL=terminal.js.map

package/dist/tools/theme.d.ts

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