@mokoconsulting/mcp-windows 3.0.0

package/dist/shell.js

@@ -0,0 +1,209 @@
+#!/usr/bin/env node
+/* Copyright (C) 2026 Moko Consulting <hello@mokoconsulting.tech>
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+import { execFile, spawn } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+const POWERSHELL = 'powershell.exe';
+const DEFAULT_TIMEOUT = 30_000;
+/**
+ * Run a PowerShell command and return stdout/stderr/exitCode.
+ * Commands are wrapped with -NoProfile -NonInteractive for speed and safety.
+ */
+export async function runPowerShell(command, options = {}) {
+    const timeout = options.timeout ?? DEFAULT_TIMEOUT;
+    try {
+        const { stdout, stderr } = await execFileAsync(POWERSHELL, [
+            '-NoProfile',
+            '-NonInteractive',
+            '-Command',
+            command,
+        ], {
+            timeout,
+            cwd: options.cwd,
+            maxBuffer: 10 * 1024 * 1024,
+            windowsHide: true,
+        });
+        return { stdout: stdout.trimEnd(), stderr: stderr.trimEnd(), exitCode: 0 };
+    }
+    catch (err) {
+        const e = err;
+        if (e.killed) {
+            return {
+                stdout: e.stdout?.trimEnd() ?? '',
+                stderr: `Command timed out after ${timeout}ms`,
+                exitCode: -1,
+            };
+        }
+        return {
+            stdout: e.stdout?.trimEnd() ?? '',
+            stderr: e.stderr?.trimEnd() ?? String(err),
+            exitCode: typeof e.code === 'number' ? e.code : 1,
+        };
+    }
+}
+/**
+ * Run a PowerShell command that returns JSON. Wraps output with ConvertTo-Json
+ * and parses the result.
+ */
+export async function runPowerShellJson(command, options = {}) {
+    const wrapped = `${command} | ConvertTo-Json -Depth 10 -Compress`;
+    const result = await runPowerShell(wrapped, options);
+    if (result.exitCode !== 0) {
+        throw new Error(result.stderr || `PowerShell exited with code ${result.exitCode}`);
+    }
+    if (!result.stdout) {
+        return [];
+    }
+    return JSON.parse(result.stdout);
+}
+/**
+ * Run a generic shell command (cmd, bash, pwsh).
+ */
+export async function runShell(command, options = {}) {
+    const shell = options.shell ?? 'pwsh';
+    const timeout = options.timeout ?? DEFAULT_TIMEOUT;
+    let executable;
+    let args;
+    switch (shell) {
+        case 'cmd':
+            executable = 'cmd.exe';
+            args = ['/c', command];
+            break;
+        case 'bash':
+            executable = 'bash';
+            args = ['-c', command];
+            break;
+        case 'pwsh':
+        default:
+            executable = POWERSHELL;
+            args = ['-NoProfile', '-NonInteractive', '-Command', command];
+            break;
+    }
+    try {
+        const { stdout, stderr } = await execFileAsync(executable, args, {
+            timeout,
+            cwd: options.cwd,
+            maxBuffer: 10 * 1024 * 1024,
+            windowsHide: true,
+        });
+        return { stdout: stdout.trimEnd(), stderr: stderr.trimEnd(), exitCode: 0 };
+    }
+    catch (err) {
+        const e = err;
+        if (e.killed) {
+            return {
+                stdout: e.stdout?.trimEnd() ?? '',
+                stderr: `Command timed out after ${timeout}ms`,
+                exitCode: -1,
+            };
+        }
+        return {
+            stdout: e.stdout?.trimEnd() ?? '',
+            stderr: e.stderr?.trimEnd() ?? String(err),
+            exitCode: typeof e.code === 'number' ? e.code : 1,
+        };
+    }
+}
+const sessions = new Map();
+const MAX_OUTPUT_LINES = 5000;
+export function startSession(shell = 'pwsh') {
+    let executable;
+    let args;
+    switch (shell) {
+        case 'cmd':
+            executable = 'cmd.exe';
+            args = [];
+            break;
+        case 'bash':
+            executable = 'bash';
+            args = [];
+            break;
+        case 'python':
+            executable = 'python';
+            args = ['-i'];
+            break;
+        case 'node':
+            executable = 'node';
+            args = [];
+            break;
+        case 'wsl':
+            executable = 'wsl.exe';
+            args = [];
+            break;
+        case 'pwsh':
+        default:
+            executable = POWERSHELL;
+            args = ['-NoProfile', '-NoLogo'];
+            break;
+    }
+    const proc = spawn(executable, args, {
+        stdio: ['pipe', 'pipe', 'pipe'],
+        windowsHide: true,
+        detached: false,
+    });
+    // Don't let terminal sessions prevent the MCP server from exiting
+    proc.unref();
+    proc.stdout?.unref?.();
+    proc.stderr?.unref?.();
+    proc.stdin?.unref?.();
+    const session = {
+        pid: proc.pid,
+        shell,
+        process: proc,
+        output: [],
+        startedAt: new Date(),
+    };
+    const pushLine = (line) => {
+        session.output.push(line);
+        if (session.output.length > MAX_OUTPUT_LINES) {
+            session.output.splice(0, session.output.length - MAX_OUTPUT_LINES);
+        }
+    };
+    proc.stdout?.on('data', (data) => {
+        data.toString().split('\n').forEach(pushLine);
+    });
+    proc.stderr?.on('data', (data) => {
+        data.toString().split('\n').forEach(l => pushLine(`[stderr] ${l}`));
+    });
+    proc.on('exit', () => {
+        pushLine(`[session ended]`);
+    });
+    sessions.set(proc.pid, session);
+    return session;
+}
+export function sendToSession(pid, input) {
+    const session = sessions.get(pid);
+    if (!session)
+        throw new Error(`No session with PID ${pid}`);
+    if (session.process.exitCode !== null)
+        throw new Error(`Session ${pid} has ended`);
+    session.process.stdin?.write(input + '\n');
+}
+export function readSessionOutput(pid, offset = 0, length) {
+    const session = sessions.get(pid);
+    if (!session)
+        throw new Error(`No session with PID ${pid}`);
+    const start = offset < 0 ? Math.max(0, session.output.length + offset) : offset;
+    const end = length !== undefined ? start + length : undefined;
+    return session.output.slice(start, end);
+}
+export function listSessions() {
+    return Array.from(sessions.values()).map(s => ({
+        pid: s.pid,
+        shell: s.shell,
+        running: s.process.exitCode === null,
+        lines: s.output.length,
+        startedAt: s.startedAt.toISOString(),
+    }));
+}
+export function terminateSession(pid) {
+    const session = sessions.get(pid);
+    if (!session)
+        return false;
+    session.process.kill();
+    sessions.delete(pid);
+    return true;
+}
+//# sourceMappingURL=shell.js.map

package/dist/tools/apps.d.ts

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

package/dist/tools/apps.js

@@ -0,0 +1,63 @@
+/* Copyright (C) 2026 Moko Consulting <hello@mokoconsulting.tech>
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ * Tool: windows_installed_apps (#19)
+ */
+import { z } from 'zod';
+import { runPowerShell } from '../shell.js';
+export function registerAppsTools(server) {
+    server.tool('windows_installed_apps', 'List installed applications from registry and Microsoft Store.', {
+        filter: z.string().optional().describe('Filter by app name (substring)'),
+        sort: z.enum(['name', 'date', 'size']).default('name').describe('Sort order'),
+        limit: z.number().default(50).describe('Max results'),
+    }, async ({ filter, sort, limit }) => {
+        const filterClause = filter
+            ? `| Where-Object { $_.DisplayName -like '*${filter.replace(/'/g, "''")}*' }`
+            : '';
+        const sortClause = sort === 'date'
+            ? '| Sort-Object InstallDate -Descending'
+            : sort === 'size'
+                ? '| Sort-Object { [int]$_.EstimatedSize } -Descending'
+                : '| Sort-Object DisplayName';
+        const ps = `
+$regPaths = @(
+  'HKLM:\\Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\*',
+  'HKLM:\\Software\\WOW6432Node\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\*',
+  'HKCU:\\Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\*'
+)
+
+$apps = $regPaths | ForEach-Object {
+  Get-ItemProperty -Path $_ -ErrorAction SilentlyContinue
+} | Where-Object { $_.DisplayName } ${filterClause} ${sortClause} |
+  Select-Object -First ${limit} |
+  ForEach-Object {
+    [PSCustomObject]@{
+      Name = $_.DisplayName
+      Version = $_.DisplayVersion
+      Publisher = $_.Publisher
+      InstallDate = $_.InstallDate
+      SizeMB = if ($_.EstimatedSize) { [math]::Round($_.EstimatedSize / 1024, 1) } else { $null }
+    }
+  }
+
+$apps | 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 apps found.' }] };
+        }
+        const apps = Array.isArray(JSON.parse(result.stdout)) ? JSON.parse(result.stdout) : [JSON.parse(result.stdout)];
+        const lines = apps.map((a) => {
+            const size = a.SizeMB ? `${String(a.SizeMB).padStart(8)} MB` : '          ';
+            const date = a.InstallDate || '          ';
+            return `${(a.Name || '').padEnd(45).slice(0, 45)}  ${(a.Version || '').padEnd(15).slice(0, 15)}  ${date.padEnd(10)}  ${size}  ${(a.Publisher || '').slice(0, 25)}`;
+        });
+        const header = `${'Name'.padEnd(45)}  ${'Version'.padEnd(15)}  ${'Installed'.padEnd(10)}  ${'Size'.padStart(11)}  Publisher`;
+        return {
+            content: [{ type: 'text', text: `${header}\n${'─'.repeat(115)}\n${lines.join('\n')}\n\n${apps.length} applications` }],
+        };
+    });
+}
+//# sourceMappingURL=apps.js.map

package/dist/tools/audio.d.ts

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

package/dist/tools/audio.js

@@ -0,0 +1,142 @@
+/* Copyright (C) 2026 Moko Consulting <hello@mokoconsulting.tech>
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ * Tools: windows_audio_get (#6), windows_audio_set (#7)
+ * Uses compiled SetMute.exe for reliable COM audio control.
+ */
+import { z } from 'zod';
+import { runPowerShell } from '../shell.js';
+const AUDIO_PS = `
+Add-Type -TypeDefinition @'
+using System;
+using System.Runtime.InteropServices;
+
+public class WinAudio {
+    [Guid("A95664D2-9614-4F35-A746-DE8DB63617E6"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    interface IMMDeviceEnumerator {
+        int EnumAudioEndpoints(int dataFlow, int dwStateMask, out IntPtr ppDevices);
+        int GetDefaultAudioEndpoint(int dataFlow, int role, out IMMDevice ppEndpoint);
+    }
+
+    [Guid("D666063F-1587-4E43-81F1-B948E807363F"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    interface IMMDevice {
+        int Activate(ref Guid iid, int dwClsCtx, IntPtr pActivationParams, [MarshalAs(UnmanagedType.IUnknown)] out object ppInterface);
+    }
+
+    [Guid("5CDF2C82-841E-4546-9722-0CF74078229A"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    interface IAudioEndpointVolume {
+        int RegisterControlChangeNotify(IntPtr pNotify);
+        int UnregisterControlChangeNotify(IntPtr pNotify);
+        int GetChannelCount(out int pnChannelCount);
+        int SetMasterVolumeLevel(float fLevelDB, ref Guid pguidEventContext);
+        int SetMasterVolumeLevelScalar(float fLevel, ref Guid pguidEventContext);
+        int GetMasterVolumeLevel(out float pfLevelDB);
+        int GetMasterVolumeLevelScalar(out float pfLevel);
+        int SetChannelVolumeLevel(int nChannel, float fLevelDB, ref Guid pguidEventContext);
+        int SetChannelVolumeLevelScalar(int nChannel, float fLevel, ref Guid pguidEventContext);
+        int GetChannelVolumeLevel(int nChannel, out float pfLevelDB);
+        int GetChannelVolumeLevelScalar(int nChannel, out float pfLevel);
+        int SetMute([MarshalAs(UnmanagedType.Bool)] bool bMute, ref Guid pguidEventContext);
+        int GetMute([MarshalAs(UnmanagedType.Bool)] out bool pbMute);
+    }
+
+    private static IAudioEndpointVolume GetVolume() {
+        var type = Type.GetTypeFromCLSID(new Guid("BCDE0395-E52F-467C-8E3D-C4579291692E"));
+        var enumerator = (IMMDeviceEnumerator)Activator.CreateInstance(type);
+        IMMDevice device;
+        enumerator.GetDefaultAudioEndpoint(0, 1, out device);
+        var iid = new Guid("5CDF2C82-841E-4546-9722-0CF74078229A");
+        object obj;
+        device.Activate(ref iid, 0x17, IntPtr.Zero, out obj);
+        return (IAudioEndpointVolume)obj;
+    }
+
+    public static float GetVolumeLevel() {
+        var vol = GetVolume();
+        float level;
+        vol.GetMasterVolumeLevelScalar(out level);
+        return level;
+    }
+
+    public static bool GetMute() {
+        var vol = GetVolume();
+        bool muted;
+        vol.GetMute(out muted);
+        return muted;
+    }
+
+    public static void SetVolumeLevel(float level) {
+        var vol = GetVolume();
+        var ctx = Guid.Empty;
+        vol.SetMasterVolumeLevelScalar(level, ref ctx);
+    }
+
+    public static void SetMute(bool mute) {
+        var vol = GetVolume();
+        var ctx = Guid.Empty;
+        vol.SetMute(mute, ref ctx);
+    }
+}
+'@ -ErrorAction Stop
+`;
+export function registerAudioTools(server) {
+    server.tool('windows_audio_get', 'Get current audio state: volume level (0-100), mute status, and default playback device.', {}, async () => {
+        const ps = `
+${AUDIO_PS}
+$volume = [math]::Round([WinAudio]::GetVolumeLevel() * 100)
+$muted = [WinAudio]::GetMute()
+$device = (Get-CimInstance Win32_SoundDevice | Where-Object { $_.Status -eq 'OK' } | Select-Object -First 1).Name
+[PSCustomObject]@{
+  volume = $volume
+  muted = $muted
+  device = $device
+} | 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 state = JSON.parse(result.stdout);
+        const muteIcon = state.muted ? '🔇' : (state.volume > 50 ? '🔊' : '🔉');
+        return {
+            content: [{
+                    type: 'text',
+                    text: `${muteIcon} Volume: ${state.volume}%${state.muted ? ' (MUTED)' : ''}\nDevice: ${state.device || 'Unknown'}`,
+                }],
+        };
+    });
+    server.tool('windows_audio_set', 'Set audio volume (0-100), mute/unmute, or toggle mute.', {
+        volume: z.number().min(0).max(100).optional().describe('Volume level 0-100'),
+        mute: z.enum(['true', 'false', 'toggle']).optional().describe('Mute state: true, false, or toggle'),
+    }, async ({ volume, mute }) => {
+        const commands = [AUDIO_PS];
+        if (volume !== undefined) {
+            commands.push(`[WinAudio]::SetVolumeLevel(${volume / 100})`);
+        }
+        if (mute === 'toggle') {
+            commands.push(`[WinAudio]::SetMute(-not [WinAudio]::GetMute())`);
+        }
+        else if (mute === 'true') {
+            commands.push(`[WinAudio]::SetMute($true)`);
+        }
+        else if (mute === 'false') {
+            commands.push(`[WinAudio]::SetMute($false)`);
+        }
+        // Read back state
+        commands.push(`
+$vol = [math]::Round([WinAudio]::GetVolumeLevel() * 100)
+$m = [WinAudio]::GetMute()
+[PSCustomObject]@{ volume = $vol; muted = $m } | ConvertTo-Json -Compress`);
+        const result = await runPowerShell(commands.join('\n'));
+        if (result.exitCode !== 0) {
+            return { content: [{ type: 'text', text: `Error: ${result.stderr}` }], isError: true };
+        }
+        const state = JSON.parse(result.stdout);
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Volume set to ${state.volume}%${state.muted ? ' (MUTED)' : ''}`,
+                }],
+        };
+    });
+}
+//# sourceMappingURL=audio.js.map

package/dist/tools/audio_apps.d.ts

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

package/dist/tools/audio_apps.js

@@ -0,0 +1,86 @@
+/* Copyright (C) 2026 Moko Consulting <hello@mokoconsulting.tech>
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ *
+ * Tool: windows_audio_app_volumes (#8)
+ */
+import { z } from 'zod';
+import { runPowerShell } from '../shell.js';
+export function registerAudioAppTools(server) {
+    server.tool('windows_audio_app_volumes', 'Get or set per-application audio volume levels. Without set params, lists all app audio sessions.', {
+        app: z.string().optional().describe('App name to target (for set operations)'),
+        volume: z.number().min(0).max(100).optional().describe('Volume to set (0-100)'),
+        mute: z.enum(['true', 'false', 'toggle']).optional().describe('Mute state to set'),
+    }, async ({ app, volume, mute }) => {
+        // List mode — show all audio sessions via PowerShell + COM
+        const ps = `
+Add-Type -TypeDefinition @'
+using System;
+using System.Runtime.InteropServices;
+using System.Collections.Generic;
+using System.Diagnostics;
+
+public class AudioSessions {
+    [Guid("A95664D2-9614-4F35-A746-DE8DB63617E6"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    interface IMMDeviceEnumerator {
+        int EnumAudioEndpoints(int dataFlow, int dwStateMask, out IntPtr ppDevices);
+        int GetDefaultAudioEndpoint(int dataFlow, int role, out IMMDevice ppEndpoint);
+    }
+
+    [Guid("D666063F-1587-4E43-81F1-B948E807363F"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    interface IMMDevice {
+        int Activate(ref Guid iid, int dwClsCtx, IntPtr pActivationParams, [MarshalAs(UnmanagedType.IUnknown)] out object ppInterface);
+    }
+
+    [Guid("77AA99A0-1BD6-484F-8BC7-2C654C9A9B6F"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    interface IAudioSessionManager2 {
+        int _0(); // QueryInterface stuff
+        int _1();
+        int GetSessionEnumerator(out IAudioSessionEnumerator ppEnum);
+    }
+
+    [Guid("E2F5BB11-0570-40CA-ACDD-3AA01277DEE8"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    interface IAudioSessionEnumerator {
+        int GetCount(out int count);
+        int GetSession(int index, [MarshalAs(UnmanagedType.IUnknown)] out object ppSession);
+    }
+
+    public static string GetSessions() {
+        // For now, use a simpler approach via Get-Process
+        return "use_powershell";
+    }
+}
+'@ -ErrorAction SilentlyContinue
+
+# Use the Volume Mixer approach via Get-Process with audio
+$sessions = Get-Process | Where-Object { $_.MainWindowTitle -ne '' -or $_.ProcessName -match 'chrome|firefox|spotify|vlc|teams|discord|zoom|music|video|media' } |
+  Select-Object Id, ProcessName, MainWindowTitle |
+  Sort-Object ProcessName -Unique
+
+$sessions | ForEach-Object {
+  [PSCustomObject]@{
+    PID = $_.Id
+    Name = $_.ProcessName
+    Title = $_.MainWindowTitle
+  }
+} | 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 (!app && volume === undefined && !mute) {
+            // List mode
+            if (!result.stdout) {
+                return { content: [{ type: 'text', text: 'No audio app sessions detected.' }] };
+            }
+            const apps = Array.isArray(JSON.parse(result.stdout)) ? JSON.parse(result.stdout) : [JSON.parse(result.stdout)];
+            const lines = apps.map((a) => `PID ${String(a.PID).padStart(6)}  ${a.Name.padEnd(25)}  ${a.Title || '(no window)'}`);
+            return {
+                content: [{ type: 'text', text: `Audio-capable processes:\n\n${lines.join('\n')}\n\nNote: Per-app volume control requires the SndVol COM API. Use windows_audio_set for master volume.` }],
+            };
+        }
+        return {
+            content: [{ type: 'text', text: `Per-app volume set/mute requires elevated SndVol COM access. Use windows_execute with PowerShell to control specific app audio, or use windows_audio_set for master volume.` }],
+        };
+    });
+}
+//# sourceMappingURL=audio_apps.js.map

package/dist/tools/automation.d.ts

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