@mokoconsulting/mcp-windows 3.0.0

package/dist/tools/process.js

@@ -0,0 +1,54 @@
+/* Copyright (C) 2026 Moko Consulting <hello@mokoconsulting.tech>
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ * Tool: windows_process_list — List running processes (#2)
+ */
+import { z } from 'zod';
+import { runPowerShell } from '../shell.js';
+export function registerProcessTools(server) {
+    server.tool('windows_process_list', 'List running processes with PID, name, CPU, memory, window title, and path.', {
+        filter: z.string().optional().describe('Filter by process name (substring match)'),
+        sort: z.enum(['cpu', 'memory', 'name']).default('memory').describe('Sort order'),
+        limit: z.number().default(50).describe('Max results to return'),
+    }, async ({ filter, sort, limit }) => {
+        const filterClause = filter
+            ? `| Where-Object { $_.Name -like '*${filter.replace(/'/g, "''")}*' }`
+            : '';
+        const sortClause = sort === 'cpu'
+            ? '| Sort-Object CPU -Descending'
+            : sort === 'name'
+                ? '| Sort-Object Name'
+                : '| Sort-Object WorkingSet64 -Descending';
+        const ps = `
+Get-Process ${filterClause} ${sortClause} | Select-Object -First ${limit} |
+ForEach-Object {
+  [PSCustomObject]@{
+    PID = $_.Id
+    Name = $_.ProcessName
+    CPU = [math]::Round($_.CPU, 1)
+    MemoryMB = [math]::Round($_.WorkingSet64 / 1MB, 1)
+    WindowTitle = $_.MainWindowTitle
+    Path = $_.Path
+  }
+} | ConvertTo-Json -Depth 3 -Compress`;
+        const result = await runPowerShell(ps);
+        if (result.exitCode !== 0) {
+            return { content: [{ type: 'text', text: `Error: ${result.stderr}` }], isError: true };
+        }
+        let processes = [];
+        if (result.stdout) {
+            const parsed = JSON.parse(result.stdout);
+            processes = Array.isArray(parsed) ? parsed : [parsed];
+        }
+        const lines = processes.map(p => `${String(p.PID).padStart(7)}  ${p.Name.padEnd(25).slice(0, 25)}  ${String(p.CPU ?? 0).padStart(8)}s  ${String(p.MemoryMB).padStart(8)} MB  ${p.WindowTitle || ''}`);
+        const header = `${'PID'.padStart(7)}  ${'Name'.padEnd(25)}  ${'CPU'.padStart(8)}   ${'Memory'.padStart(8)}     Window Title`;
+        const separator = '-'.repeat(90);
+        return {
+            content: [{
+                    type: 'text',
+                    text: `${header}\n${separator}\n${lines.join('\n')}\n\n${processes.length} processes`,
+                }],
+        };
+    });
+}
+//# sourceMappingURL=process.js.map

package/dist/tools/process_kill.d.ts

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

package/dist/tools/process_kill.js

@@ -0,0 +1,48 @@
+/* Copyright (C) 2026 Moko Consulting <hello@mokoconsulting.tech>
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ * Tool: windows_process_kill (#3)
+ */
+import { z } from 'zod';
+import { runPowerShell } from '../shell.js';
+export function registerProcessKillTools(server) {
+    server.tool('windows_process_kill', 'Terminate running processes by PID or name.', {
+        pid: z.number().optional().describe('Process ID to kill'),
+        name: z.string().optional().describe('Process name to kill (all matching)'),
+        force: z.boolean().default(false).describe('Force termination'),
+    }, async ({ pid, name, force }) => {
+        if (!pid && !name) {
+            return { content: [{ type: 'text', text: 'Provide either pid or name.' }], isError: true };
+        }
+        const forceFlag = force ? ' -Force' : '';
+        let ps;
+        if (pid) {
+            ps = `
+$p = Get-Process -Id ${pid} -ErrorAction SilentlyContinue
+if ($p) {
+  $n = $p.ProcessName
+  Stop-Process -Id ${pid}${forceFlag} -ErrorAction Stop
+  "Killed PID ${pid} ($n)"
+} else {
+  "No process with PID ${pid}"
+}`;
+        }
+        else {
+            ps = `
+$procs = Get-Process -Name '${name.replace(/'/g, "''")}' -ErrorAction SilentlyContinue
+if ($procs) {
+  $count = @($procs).Count
+  $procs | Stop-Process${forceFlag} -ErrorAction Stop
+  "Killed $count process(es) named '${name}'"
+} else {
+  "No processes named '${name}'"
+}`;
+        }
+        const result = await runPowerShell(ps);
+        return {
+            content: [{ type: 'text', text: result.stdout || result.stderr }],
+            isError: result.exitCode !== 0,
+        };
+    });
+}
+//# sourceMappingURL=process_kill.js.map

package/dist/tools/recycle_bin.d.ts

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

package/dist/tools/recycle_bin.js

@@ -0,0 +1,108 @@
+/* Copyright (C) 2026 Moko Consulting <hello@mokoconsulting.tech>
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ * Tool: windows_recycle_bin (#26)
+ */
+import { z } from 'zod';
+import { runPowerShell } from '../shell.js';
+export function registerRecycleBinTools(server) {
+    server.tool('windows_recycle_bin', 'Manage the Recycle Bin: list items, get size, restore items, or empty.', {
+        action: z.enum(['list', 'size', 'empty', 'restore']).default('list').describe('Action'),
+        filter: z.string().optional().describe('Filter by filename (for list/restore)'),
+        limit: z.number().default(30).describe('Max items (for list)'),
+    }, async ({ action, filter, limit }) => {
+        switch (action) {
+            case 'size': {
+                const ps = `
+$shell = New-Object -ComObject Shell.Application
+$bin = $shell.Namespace(10)
+$items = $bin.Items()
+$count = $items.Count
+$totalSize = 0
+for ($i = 0; $i -lt $count; $i++) {
+  $totalSize += $bin.GetDetailsOf($items.Item($i), 2) -replace '[^0-9]','' -as [long]
+}
+[PSCustomObject]@{
+  Count = $count
+  SizeMB = [math]::Round($totalSize / 1MB, 1)
+} | ConvertTo-Json -Compress`;
+                const result = await runPowerShell(ps, { timeout: 15000 });
+                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: `Recycle Bin: ${info.Count} items, ${info.SizeMB} MB` }] };
+            }
+            case 'list': {
+                const filterClause = filter
+                    ? `| Where-Object { $_.Name -like '*${filter.replace(/'/g, "''")}*' }`
+                    : '';
+                const ps = `
+$shell = New-Object -ComObject Shell.Application
+$bin = $shell.Namespace(10)
+$items = @()
+foreach ($item in $bin.Items()) {
+  $items += [PSCustomObject]@{
+    Name = $item.Name
+    OriginalPath = $bin.GetDetailsOf($item, 1)
+    Size = $bin.GetDetailsOf($item, 2)
+    DeletedDate = $bin.GetDetailsOf($item, 3)
+    Type = $bin.GetDetailsOf($item, 4)
+  }
+}
+$items ${filterClause} | Select-Object -First ${limit} | 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: 'Recycle Bin is empty.' }] };
+                }
+                const items = Array.isArray(JSON.parse(result.stdout)) ? JSON.parse(result.stdout) : [JSON.parse(result.stdout)];
+                const lines = items.map((i) => `${(i.Name || '').padEnd(35).slice(0, 35)}  ${(i.Size || '').padStart(10)}  ${(i.DeletedDate || '').padEnd(20)}  ${(i.OriginalPath || '').slice(0, 40)}`);
+                const header = `${'Name'.padEnd(35)}  ${'Size'.padStart(10)}  ${'Deleted'.padEnd(20)}  Original Path`;
+                return {
+                    content: [{ type: 'text', text: `${header}\n${'─'.repeat(110)}\n${lines.join('\n')}\n\n${items.length} items` }],
+                };
+            }
+            case 'empty': {
+                const ps = `
+$shell = New-Object -ComObject Shell.Application
+$count = $shell.Namespace(10).Items().Count
+if ($count -eq 0) { "Recycle Bin is already empty." }
+else {
+  Clear-RecycleBin -Force -ErrorAction Stop
+  "Emptied Recycle Bin ($count items removed)"
+}`;
+                const result = await runPowerShell(ps, { timeout: 15000 });
+                return {
+                    content: [{ type: 'text', text: result.stdout || result.stderr }],
+                    isError: result.exitCode !== 0,
+                };
+            }
+            case 'restore': {
+                if (!filter) {
+                    return { content: [{ type: 'text', text: 'Restore requires a filter to identify which item(s) to restore.' }], isError: true };
+                }
+                const ps = `
+$shell = New-Object -ComObject Shell.Application
+$bin = $shell.Namespace(10)
+$restored = 0
+foreach ($item in $bin.Items()) {
+  if ($item.Name -like '*${filter.replace(/'/g, "''")}*') {
+    $origPath = $bin.GetDetailsOf($item, 1)
+    $item.InvokeVerb('undelete')
+    $restored++
+  }
+}
+if ($restored -gt 0) { "Restored $restored item(s)" } else { "No matching items found" }`;
+                const result = await runPowerShell(ps, { timeout: 15000 });
+                return {
+                    content: [{ type: 'text', text: result.stdout || result.stderr }],
+                    isError: result.exitCode !== 0,
+                };
+            }
+        }
+    });
+}
+//# sourceMappingURL=recycle_bin.js.map

package/dist/tools/registry.d.ts

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

package/dist/tools/registry.js

@@ -0,0 +1,136 @@
+/* Copyright (C) 2026 Moko Consulting <hello@mokoconsulting.tech>
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ * Tools: windows_registry_read (#29), windows_registry_write (#30)
+ */
+import { z } from 'zod';
+import { runPowerShell } from '../shell.js';
+function expandHive(path) {
+    return path
+        .replace(/^HKLM[:\\\/]/i, 'HKLM:\\')
+        .replace(/^HKCU[:\\\/]/i, 'HKCU:\\')
+        .replace(/^HKCR[:\\\/]/i, 'HKCR:\\')
+        .replace(/^HKU[:\\\/]/i, 'HKU:\\')
+        .replace(/^HKCC[:\\\/]/i, 'HKCC:\\');
+}
+export function registerRegistryTools(server) {
+    server.tool('windows_registry_read', 'Read Windows Registry keys, subkeys, and values. Supports HKLM, HKCU, HKCR abbreviations.', {
+        path: z.string().describe('Registry path (e.g. "HKCU:\\Software\\Microsoft")'),
+        value: z.string().optional().describe('Specific value name to read (omit to list all values)'),
+        subkeys: z.boolean().default(false).describe('List subkeys instead of values'),
+    }, async ({ path, value, subkeys }) => {
+        const regPath = expandHive(path);
+        if (subkeys) {
+            const ps = `
+Get-ChildItem -Path '${regPath.replace(/'/g, "''")}' -ErrorAction Stop | ForEach-Object {
+  [PSCustomObject]@{
+    Name = $_.PSChildName
+    SubKeyCount = $_.SubKeyCount
+    ValueCount = $_.ValueCount
+  }
+} | 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 subkeys found.' }] };
+            }
+            const keys = Array.isArray(JSON.parse(result.stdout)) ? JSON.parse(result.stdout) : [JSON.parse(result.stdout)];
+            const lines = keys.map((k) => `  ${k.Name.padEnd(40)}  ${k.SubKeyCount} subkeys, ${k.ValueCount} values`);
+            return { content: [{ type: 'text', text: `${regPath}\n${'─'.repeat(70)}\n${lines.join('\n')}` }] };
+        }
+        if (value) {
+            const ps = `
+$v = Get-ItemProperty -Path '${regPath.replace(/'/g, "''")}' -Name '${value.replace(/'/g, "''")}' -ErrorAction Stop
+$raw = $v.'${value.replace(/'/g, "''")}'
+$kind = (Get-Item -Path '${regPath.replace(/'/g, "''")}' -ErrorAction Stop).GetValueKind('${value.replace(/'/g, "''")}')
+[PSCustomObject]@{
+  Name = '${value.replace(/'/g, "''")}'
+  Type = $kind.ToString()
+  Value = $raw
+} | 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 v = JSON.parse(result.stdout);
+            return { content: [{ type: 'text', text: `${regPath}\\${v.Name}\nType: ${v.Type}\nValue: ${JSON.stringify(v.Value)}` }] };
+        }
+        // List all values
+        const ps = `
+$key = Get-Item -Path '${regPath.replace(/'/g, "''")}' -ErrorAction Stop
+$key.GetValueNames() | ForEach-Object {
+  $name = $_
+  $val = $key.GetValue($name)
+  $kind = $key.GetValueKind($name)
+  [PSCustomObject]@{
+    Name = if ($name) { $name } else { '(Default)' }
+    Type = $kind.ToString()
+    Value = $val
+  }
+} | 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 values found.' }] };
+        }
+        const values = Array.isArray(JSON.parse(result.stdout)) ? JSON.parse(result.stdout) : [JSON.parse(result.stdout)];
+        const lines = values.map((v) => {
+            const valStr = typeof v.Value === 'string' ? v.Value : JSON.stringify(v.Value);
+            return `  ${v.Name.padEnd(30)}  ${v.Type.padEnd(12)}  ${valStr.slice(0, 60)}`;
+        });
+        const header = `  ${'Name'.padEnd(30)}  ${'Type'.padEnd(12)}  Value`;
+        return { content: [{ type: 'text', text: `${regPath}\n${header}\n${'─'.repeat(80)}\n${lines.join('\n')}` }] };
+    });
+    server.tool('windows_registry_write', 'Write Windows Registry values. Restricted to HKCU by default. Use hklm_override for HKLM writes.', {
+        path: z.string().describe('Registry path'),
+        name: z.string().describe('Value name'),
+        value: z.string().describe('Value data'),
+        type: z.enum(['String', 'DWord', 'QWord', 'Binary', 'ExpandString', 'MultiString']).default('String').describe('Value type'),
+        hklm_override: z.boolean().default(false).describe('Allow writing to HKLM (requires elevation)'),
+        action: z.enum(['set', 'delete', 'create_key', 'delete_key']).default('set').describe('Action'),
+    }, async ({ path, name, value, type, hklm_override, action }) => {
+        const regPath = expandHive(path);
+        // Safety check
+        if (regPath.startsWith('HKLM:') && !hklm_override) {
+            return {
+                content: [{ type: 'text', text: 'HKLM writes are restricted. Set hklm_override=true and ensure elevation.' }],
+                isError: true,
+            };
+        }
+        let ps;
+        switch (action) {
+            case 'set': {
+                const typeMap = {
+                    String: 'String', DWord: 'DWord', QWord: 'QWord',
+                    Binary: 'Binary', ExpandString: 'ExpandString', MultiString: 'MultiString',
+                };
+                ps = `
+if (-not (Test-Path '${regPath.replace(/'/g, "''")}')) {
+  New-Item -Path '${regPath.replace(/'/g, "''")}' -Force | Out-Null
+}
+Set-ItemProperty -Path '${regPath.replace(/'/g, "''")}' -Name '${name.replace(/'/g, "''")}' -Value '${value.replace(/'/g, "''")}' -Type ${typeMap[type]} -ErrorAction Stop
+"Set ${regPath}\\${name} = ${value} (${type})"`;
+                break;
+            }
+            case 'delete':
+                ps = `Remove-ItemProperty -Path '${regPath.replace(/'/g, "''")}' -Name '${name.replace(/'/g, "''")}' -ErrorAction Stop; "Deleted ${regPath}\\${name}"`;
+                break;
+            case 'create_key':
+                ps = `New-Item -Path '${regPath.replace(/'/g, "''")}' -Force -ErrorAction Stop | Out-Null; "Created key ${regPath}"`;
+                break;
+            case 'delete_key':
+                ps = `Remove-Item -Path '${regPath.replace(/'/g, "''")}' -Recurse -Force -ErrorAction Stop; "Deleted key ${regPath}"`;
+                break;
+        }
+        const result = await runPowerShell(ps, { timeout: 10000 });
+        return {
+            content: [{ type: 'text', text: result.stdout || result.stderr }],
+            isError: result.exitCode !== 0,
+        };
+    });
+}
+//# sourceMappingURL=registry.js.map

package/dist/tools/scheduler.d.ts

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

package/dist/tools/scheduler.js

@@ -0,0 +1,116 @@
+/* Copyright (C) 2026 Moko Consulting <hello@mokoconsulting.tech>
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ * Tools: windows_task_scheduler_list (#27), windows_task_scheduler_manage (#28)
+ */
+import { z } from 'zod';
+import { runPowerShell } from '../shell.js';
+export function registerSchedulerTools(server) {
+    server.tool('windows_task_scheduler_list', 'List Windows Task Scheduler tasks with status, last/next run, and trigger type.', {
+        folder: z.string().default('\\').describe('Task folder path (e.g. "\\" for root, "\\Microsoft\\")'),
+        filter: z.string().optional().describe('Filter by task name (substring)'),
+    }, async ({ folder, filter }) => {
+        const filterClause = filter
+            ? `| Where-Object { $_.TaskName -like '*${filter.replace(/'/g, "''")}*' }`
+            : '';
+        const ps = `
+Get-ScheduledTask -TaskPath '${folder.replace(/'/g, "''")}*' -ErrorAction SilentlyContinue ${filterClause} | ForEach-Object {
+  $info = $_ | Get-ScheduledTaskInfo -ErrorAction SilentlyContinue
+  [PSCustomObject]@{
+    Name = $_.TaskName
+    Path = $_.TaskPath
+    State = $_.State.ToString()
+    LastRun = if ($info.LastRunTime -and $info.LastRunTime.Year -gt 1999) { $info.LastRunTime.ToString('yyyy-MM-dd HH:mm') } else { 'Never' }
+    NextRun = if ($info.NextRunTime -and $info.NextRunTime.Year -gt 1999) { $info.NextRunTime.ToString('yyyy-MM-dd HH:mm') } else { 'N/A' }
+    LastResult = if ($info) { '0x{0:X}' -f $info.LastTaskResult } else { 'N/A' }
+    Triggers = ($_.Triggers | ForEach-Object { $_.CimClass.CimClassName -replace 'MSFT_Task',''-replace 'Trigger','' }) -join ', '
+  }
+} | ConvertTo-Json -Depth 3 -Compress`;
+        const result = await runPowerShell(ps, { timeout: 30000 });
+        if (result.exitCode !== 0) {
+            return { content: [{ type: 'text', text: `Error: ${result.stderr}` }], isError: true };
+        }
+        if (!result.stdout) {
+            return { content: [{ type: 'text', text: 'No tasks found.' }] };
+        }
+        const tasks = Array.isArray(JSON.parse(result.stdout)) ? JSON.parse(result.stdout) : [JSON.parse(result.stdout)];
+        const lines = tasks.map((t) => {
+            const state = t.State === 'Ready' ? '[RDY]' : t.State === 'Running' ? '[RUN]' : t.State === 'Disabled' ? '[OFF]' : `[${t.State.slice(0, 3).toUpperCase()}]`;
+            return `${state}  ${t.Name.padEnd(40).slice(0, 40)}  ${t.LastRun.padEnd(16)}  ${t.NextRun.padEnd(16)}  ${t.Triggers}`;
+        });
+        const header = `State  ${'Name'.padEnd(40)}  ${'Last Run'.padEnd(16)}  ${'Next Run'.padEnd(16)}  Triggers`;
+        return {
+            content: [{ type: 'text', text: `${header}\n${'─'.repeat(110)}\n${lines.join('\n')}\n\n${tasks.length} tasks` }],
+        };
+    });
+    server.tool('windows_task_scheduler_manage', 'Create, delete, enable, disable, or run a scheduled task.', {
+        action: z.enum(['create', 'delete', 'enable', 'disable', 'run']).describe('Action to perform'),
+        name: z.string().describe('Task name'),
+        command: z.string().optional().describe('Command to execute (for create)'),
+        arguments: z.string().optional().describe('Command arguments (for create)'),
+        trigger: z.enum(['once', 'daily', 'weekly', 'hourly', 'logon', 'startup']).optional().describe('Trigger type (for create)'),
+        time: z.string().optional().describe('Time for trigger as HH:mm (for create with once/daily/weekly)'),
+        interval: z.number().optional().describe('Repetition interval in minutes (for create with hourly)'),
+    }, async ({ action, name, command, arguments: args, trigger, time, interval }) => {
+        let ps;
+        switch (action) {
+            case 'run':
+                ps = `Start-ScheduledTask -TaskName '${name.replace(/'/g, "''")}' -ErrorAction Stop; "Task '${name}' started"`;
+                break;
+            case 'enable':
+                ps = `Enable-ScheduledTask -TaskName '${name.replace(/'/g, "''")}' -ErrorAction Stop | Select-Object TaskName,State | ConvertTo-Json -Compress`;
+                break;
+            case 'disable':
+                ps = `Disable-ScheduledTask -TaskName '${name.replace(/'/g, "''")}' -ErrorAction Stop | Select-Object TaskName,State | ConvertTo-Json -Compress`;
+                break;
+            case 'delete':
+                ps = `Unregister-ScheduledTask -TaskName '${name.replace(/'/g, "''")}' -Confirm:$false -ErrorAction Stop; "Task '${name}' deleted"`;
+                break;
+            case 'create': {
+                if (!command) {
+                    return { content: [{ type: 'text', text: 'Create requires command.' }], isError: true };
+                }
+                if (!trigger) {
+                    return { content: [{ type: 'text', text: 'Create requires trigger type.' }], isError: true };
+                }
+                const actionPart = args
+                    ? `$action = New-ScheduledTaskAction -Execute '${command.replace(/'/g, "''")}' -Argument '${args.replace(/'/g, "''")}'`
+                    : `$action = New-ScheduledTaskAction -Execute '${command.replace(/'/g, "''")}'`;
+                let triggerPart;
+                switch (trigger) {
+                    case 'once':
+                        triggerPart = `$trigger = New-ScheduledTaskTrigger -Once -At '${time || '00:00'}'`;
+                        break;
+                    case 'daily':
+                        triggerPart = `$trigger = New-ScheduledTaskTrigger -Daily -At '${time || '00:00'}'`;
+                        break;
+                    case 'weekly':
+                        triggerPart = `$trigger = New-ScheduledTaskTrigger -Weekly -DaysOfWeek Monday -At '${time || '00:00'}'`;
+                        break;
+                    case 'hourly':
+                        triggerPart = `$trigger = New-ScheduledTaskTrigger -Once -At '00:00' -RepetitionInterval (New-TimeSpan -Minutes ${interval || 60}) -RepetitionDuration (New-TimeSpan -Days 9999)`;
+                        break;
+                    case 'logon':
+                        triggerPart = `$trigger = New-ScheduledTaskTrigger -AtLogOn`;
+                        break;
+                    case 'startup':
+                        triggerPart = `$trigger = New-ScheduledTaskTrigger -AtStartup`;
+                        break;
+                }
+                ps = `
+${actionPart}
+${triggerPart}
+$settings = New-ScheduledTaskSettingsSet -AllowStartIfOnBatteries -DontStopIfGoingOnBatteries -StartWhenAvailable
+Register-ScheduledTask -TaskName '${name.replace(/'/g, "''")}' -Action $action -Trigger $trigger -Settings $settings -Force -ErrorAction Stop |
+  Select-Object TaskName,State | ConvertTo-Json -Compress`;
+                break;
+            }
+        }
+        const result = await runPowerShell(ps, { timeout: 15000 });
+        if (result.exitCode !== 0) {
+            return { content: [{ type: 'text', text: `Error: ${result.stderr}` }], isError: true };
+        }
+        return { content: [{ type: 'text', text: result.stdout }] };
+    });
+}
+//# sourceMappingURL=scheduler.js.map

package/dist/tools/service.d.ts

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

package/dist/tools/service.js

@@ -0,0 +1,79 @@
+/* Copyright (C) 2026 Moko Consulting <hello@mokoconsulting.tech>
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ * Tools: windows_service_list (#4), windows_service_control (#5)
+ */
+import { z } from 'zod';
+import { runPowerShell } from '../shell.js';
+export function registerServiceTools(server) {
+    server.tool('windows_service_list', 'List Windows services with status, startup type, and description.', {
+        filter: z.string().optional().describe('Filter by service name or display name (substring)'),
+        status: z.enum(['running', 'stopped', 'all']).default('all').describe('Filter by status'),
+    }, async ({ filter, status }) => {
+        const filterClause = filter
+            ? `| Where-Object { $_.Name -like '*${filter.replace(/'/g, "''")}*' -or $_.DisplayName -like '*${filter.replace(/'/g, "''")}*' }`
+            : '';
+        const statusClause = status === 'running'
+            ? `| Where-Object { $_.Status -eq 'Running' }`
+            : status === 'stopped'
+                ? `| Where-Object { $_.Status -eq 'Stopped' }`
+                : '';
+        const ps = `
+$wmiCache = @{}
+Get-CimInstance Win32_Service -ErrorAction SilentlyContinue | ForEach-Object { $wmiCache[$_.Name] = $_.Description }
+Get-Service ${filterClause} ${statusClause} | Sort-Object DisplayName | ForEach-Object {
+  [PSCustomObject]@{
+    Name = $_.Name
+    DisplayName = $_.DisplayName
+    Status = $_.Status.ToString()
+    StartType = $_.StartType.ToString()
+    Description = if ($wmiCache[$_.Name]) { $wmiCache[$_.Name] } else { '' }
+  }
+} | ConvertTo-Json -Depth 3 -Compress`;
+        const result = await runPowerShell(ps, { timeout: 45000 });
+        if (result.exitCode !== 0) {
+            return { content: [{ type: 'text', text: `Error: ${result.stderr}` }], isError: true };
+        }
+        if (!result.stdout) {
+            return { content: [{ type: 'text', text: 'No services found.' }] };
+        }
+        const services = Array.isArray(JSON.parse(result.stdout)) ? JSON.parse(result.stdout) : [JSON.parse(result.stdout)];
+        const lines = services.map((s) => `${s.Status === 'Running' ? '[RUN]' : '[STP]'}  ${s.StartType.padEnd(10)}  ${s.Name.padEnd(35).slice(0, 35)}  ${s.DisplayName}`);
+        const header = `${'State'.padEnd(5)}  ${'Startup'.padEnd(10)}  ${'Name'.padEnd(35)}  Display Name`;
+        return {
+            content: [{ type: 'text', text: `${header}\n${'─'.repeat(100)}\n${lines.join('\n')}\n\n${services.length} services` }],
+        };
+    });
+    server.tool('windows_service_control', 'Start, stop, restart, or change startup type of a Windows service.', {
+        name: z.string().describe('Service name or display name'),
+        action: z.enum(['start', 'stop', 'restart', 'enable', 'disable']).describe('Action to perform'),
+    }, async ({ name, action }) => {
+        let ps;
+        switch (action) {
+            case 'start':
+                ps = `Start-Service -Name '${name.replace(/'/g, "''")}' -ErrorAction Stop; Get-Service -Name '${name.replace(/'/g, "''")}' | Select-Object Name,Status,StartType | ConvertTo-Json -Compress`;
+                break;
+            case 'stop':
+                ps = `Stop-Service -Name '${name.replace(/'/g, "''")}' -Force -ErrorAction Stop; Get-Service -Name '${name.replace(/'/g, "''")}' | Select-Object Name,Status,StartType | ConvertTo-Json -Compress`;
+                break;
+            case 'restart':
+                ps = `Restart-Service -Name '${name.replace(/'/g, "''")}' -Force -ErrorAction Stop; Get-Service -Name '${name.replace(/'/g, "''")}' | Select-Object Name,Status,StartType | ConvertTo-Json -Compress`;
+                break;
+            case 'enable':
+                ps = `Set-Service -Name '${name.replace(/'/g, "''")}' -StartupType Automatic -ErrorAction Stop; Get-Service -Name '${name.replace(/'/g, "''")}' | Select-Object Name,Status,StartType | ConvertTo-Json -Compress`;
+                break;
+            case 'disable':
+                ps = `Set-Service -Name '${name.replace(/'/g, "''")}' -StartupType Disabled -ErrorAction Stop; Get-Service -Name '${name.replace(/'/g, "''")}' | Select-Object Name,Status,StartType | ConvertTo-Json -Compress`;
+                break;
+        }
+        const result = await runPowerShell(ps, { timeout: 15000 });
+        if (result.exitCode !== 0) {
+            return { content: [{ type: 'text', text: `Error: ${result.stderr}` }], isError: true };
+        }
+        const svc = JSON.parse(result.stdout);
+        return {
+            content: [{ type: 'text', text: `Service "${svc.Name}": ${action} → Status: ${svc.Status}, StartType: ${svc.StartType}` }],
+        };
+    });
+}
+//# sourceMappingURL=service.js.map

package/dist/tools/startup.d.ts

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