@azurestacknerd/roon-mcp 1.0.1

package/build/tools/volume.js

@@ -0,0 +1,115 @@
+import { z } from "zod";
+import { roonConnection } from "../roon-connection.js";
+function promisifyResult(fn) {
+    return new Promise((resolve) => fn((error) => resolve(error)));
+}
+export function registerVolumeTools(server) {
+    server.tool("change_volume", "Change the volume of a Roon zone. Each output in a zone may have independent volume controls.", {
+        zone: z.string().describe("Zone name or ID"),
+        value: z.number().describe("Volume value (absolute level, or relative adjustment)"),
+        how: z
+            .enum(["absolute", "relative", "relative_step"])
+            .default("absolute")
+            .describe("How to interpret the value: 'absolute' sets exact level, 'relative' adds/subtracts, 'relative_step' adjusts by step increments"),
+    }, async ({ zone, value, how }) => {
+        try {
+            const transport = roonConnection.getTransport();
+            const foundZone = roonConnection.findZoneOrThrow(zone);
+            const results = [];
+            for (const output of foundZone.outputs) {
+                if (!output.volume)
+                    continue;
+                const error = await promisifyResult((cb) => transport.change_volume(output, how, value, cb));
+                if (error) {
+                    results.push(`${output.display_name}: Error - ${error}`);
+                }
+                else {
+                    results.push(`${output.display_name}: Volume ${how === "absolute" ? "set to" : "adjusted by"} ${value}`);
+                }
+            }
+            if (results.length === 0) {
+                return {
+                    content: [{ type: "text", text: `No volume-controllable outputs in zone '${foundZone.display_name}'.` }],
+                };
+            }
+            return { content: [{ type: "text", text: results.join("\n") }] };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: String(error instanceof Error ? error.message : error) }],
+                isError: true,
+            };
+        }
+    });
+    server.tool("mute", "Mute or unmute a Roon zone", {
+        zone: z.string().describe("Zone name or ID"),
+        mute: z.boolean().describe("true to mute, false to unmute"),
+    }, async ({ zone, mute }) => {
+        try {
+            const transport = roonConnection.getTransport();
+            const foundZone = roonConnection.findZoneOrThrow(zone);
+            const how = mute ? "mute" : "unmute";
+            const results = [];
+            for (const output of foundZone.outputs) {
+                if (!output.volume)
+                    continue;
+                const error = await promisifyResult((cb) => transport.mute(output, how, cb));
+                if (error) {
+                    results.push(`${output.display_name}: Error - ${error}`);
+                }
+                else {
+                    results.push(`${output.display_name}: ${mute ? "Muted" : "Unmuted"}`);
+                }
+            }
+            if (results.length === 0) {
+                return {
+                    content: [{ type: "text", text: `No volume-controllable outputs in zone '${foundZone.display_name}'.` }],
+                };
+            }
+            return { content: [{ type: "text", text: results.join("\n") }] };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: String(error instanceof Error ? error.message : error) }],
+                isError: true,
+            };
+        }
+    });
+    server.tool("get_volume", "Get the current volume level and mute status for a Roon zone", {
+        zone: z.string().describe("Zone name or ID"),
+    }, async ({ zone }) => {
+        try {
+            roonConnection.getTransport();
+            const foundZone = roonConnection.findZoneOrThrow(zone);
+            const lines = [`Zone: ${foundZone.display_name}`];
+            for (const output of foundZone.outputs) {
+                if (output.volume) {
+                    const vol = output.volume;
+                    const parts = [`${output.display_name}:`];
+                    if (vol.type === "incremental") {
+                        parts.push("Incremental volume (no level readout)");
+                    }
+                    else {
+                        parts.push(`${vol.value}${vol.type === "db" ? " dB" : ""}`);
+                        if (vol.min != null && vol.max != null) {
+                            parts.push(`(range: ${vol.min} to ${vol.max})`);
+                        }
+                    }
+                    if (vol.is_muted)
+                        parts.push("[MUTED]");
+                    lines.push(`  ${parts.join(" ")}`);
+                }
+                else {
+                    lines.push(`  ${output.display_name}: No volume control`);
+                }
+            }
+            return { content: [{ type: "text", text: lines.join("\n") }] };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: String(error instanceof Error ? error.message : error) }],
+                isError: true,
+            };
+        }
+    });
+}

package/build/tools/zone.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerZoneTools(server: McpServer): void;

package/build/tools/zone.js

@@ -0,0 +1,153 @@
+import { z } from "zod";
+import { roonConnection } from "../roon-connection.js";
+export function registerZoneTools(server) {
+    server.tool("list_zones", "List all available Roon zones with their current playback status", {}, async () => {
+        try {
+            // Ensure we're connected (will throw if not)
+            roonConnection.getTransport();
+            const zones = roonConnection.getZones();
+            if (zones.length === 0) {
+                return {
+                    content: [{ type: "text", text: "No zones found. Is Roon running?" }],
+                };
+            }
+            const zoneList = zones.map((zone) => {
+                const np = zone.now_playing;
+                const nowPlaying = np
+                    ? `${np.three_line.line1}${np.three_line.line2 ? ` - ${np.three_line.line2}` : ""}${np.three_line.line3 ? ` (${np.three_line.line3})` : ""}`
+                    : "Nothing playing";
+                return [
+                    `Zone: ${zone.display_name}`,
+                    `  State: ${zone.state}`,
+                    `  Now Playing: ${nowPlaying}`,
+                    np?.seek_position != null && np?.length
+                        ? `  Position: ${formatTime(np.seek_position)} / ${formatTime(np.length)}`
+                        : null,
+                    zone.queue_items_remaining
+                        ? `  Queue: ${zone.queue_items_remaining} items remaining`
+                        : null,
+                ]
+                    .filter(Boolean)
+                    .join("\n");
+            });
+            return {
+                content: [{ type: "text", text: zoneList.join("\n\n") }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: String(error instanceof Error ? error.message : error) }],
+                isError: true,
+            };
+        }
+    });
+    server.tool("now_playing", "Get detailed information about what is currently playing in a Roon zone", {
+        zone: z.string().optional().describe("Zone name or ID. If omitted, returns info for all playing zones"),
+    }, async ({ zone }) => {
+        try {
+            roonConnection.getTransport();
+            if (zone) {
+                const z = roonConnection.findZoneOrThrow(zone);
+                return {
+                    content: [{ type: "text", text: formatNowPlaying(z) }],
+                };
+            }
+            // Return all zones that are playing
+            const zones = roonConnection.getZones();
+            const playing = zones.filter((z) => z.now_playing);
+            if (playing.length === 0) {
+                return {
+                    content: [{ type: "text", text: "Nothing is currently playing in any zone." }],
+                };
+            }
+            const result = playing.map(formatNowPlaying).join("\n\n---\n\n");
+            return {
+                content: [{ type: "text", text: result }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: String(error instanceof Error ? error.message : error) }],
+                isError: true,
+            };
+        }
+    });
+    server.tool("get_queue", "Get the play queue for a Roon zone", {
+        zone: z.string().describe("Zone name or ID"),
+    }, async ({ zone }) => {
+        try {
+            const transport = roonConnection.getTransport();
+            const z = roonConnection.findZoneOrThrow(zone);
+            const items = await new Promise((resolve, reject) => {
+                const timeout = setTimeout(() => reject(new Error("Queue request timed out")), 5000);
+                const sub = transport.subscribe_queue(z, 100, (response, msg) => {
+                    if (response === "Subscribed") {
+                        clearTimeout(timeout);
+                        resolve(msg.items || []);
+                        // Unsubscribe after getting the initial data
+                        try {
+                            sub.unsubscribe();
+                        }
+                        catch { /* ignore */ }
+                    }
+                });
+            });
+            if (items.length === 0) {
+                return {
+                    content: [{ type: "text", text: `Queue for '${z.display_name}' is empty.` }],
+                };
+            }
+            const lines = [`Queue for '${z.display_name}' (${items.length} items):\n`];
+            for (let i = 0; i < items.length; i++) {
+                const item = items[i];
+                const duration = item.length ? ` [${formatTime(item.length)}]` : "";
+                const artist = item.two_line.line2 ? ` - ${item.two_line.line2}` : "";
+                lines.push(`${i + 1}. ${item.two_line.line1}${artist}${duration}`);
+            }
+            return {
+                content: [{ type: "text", text: lines.join("\n") }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: String(error instanceof Error ? error.message : error) }],
+                isError: true,
+            };
+        }
+    });
+}
+function formatNowPlaying(zone) {
+    const np = zone.now_playing;
+    if (!np) {
+        return `${zone.display_name}: Nothing playing (${zone.state})`;
+    }
+    const lines = [
+        `Zone: ${zone.display_name}`,
+        `State: ${zone.state}`,
+        `Track: ${np.three_line.line1}`,
+    ];
+    if (np.three_line.line2)
+        lines.push(`Artist: ${np.three_line.line2}`);
+    if (np.three_line.line3)
+        lines.push(`Album: ${np.three_line.line3}`);
+    if (np.seek_position != null && np.length) {
+        lines.push(`Position: ${formatTime(np.seek_position)} / ${formatTime(np.length)}`);
+    }
+    if (zone.settings) {
+        const settings = [];
+        if (zone.settings.shuffle)
+            settings.push("Shuffle");
+        if (zone.settings.loop !== "disabled")
+            settings.push(`Loop: ${zone.settings.loop}`);
+        if (zone.settings.auto_radio)
+            settings.push("Radio");
+        if (settings.length > 0)
+            lines.push(`Settings: ${settings.join(", ")}`);
+    }
+    return lines.join("\n");
+}
+function formatTime(seconds) {
+    const mins = Math.floor(seconds / 60);
+    const secs = Math.floor(seconds % 60);
+    return `${mins}:${secs.toString().padStart(2, "0")}`;
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@azurestacknerd/roon-mcp",
+  "version": "1.0.1",
+  "description": "MCP server for controlling Roon music playback via Claude Desktop",
+  "mcpName": "io.github.azurestacknerd/roon-mcp",
+  "type": "module",
+  "main": "build/index.js",
+  "bin": {
+    "roon-mcp": "./build/index.js"
+  },
+  "keywords": ["mcp", "roon", "audio", "music", "model-context-protocol"],
+  "author": "AzureStackNerd",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/AzureStackNerd/roon-mcp.git"
+  },
+  "files": [
+    "build",
+    "scripts"
+  ],
+  "scripts": {
+    "postinstall": "node scripts/patch-roon-api.js",
+    "build": "tsc",
+    "start": "node build/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "node-roon-api": "github:roonlabs/node-roon-api",
+    "node-roon-api-browse": "github:roonlabs/node-roon-api-browse",
+    "node-roon-api-status": "github:roonlabs/node-roon-api-status",
+    "node-roon-api-transport": "github:roonlabs/node-roon-api-transport",
+    "zod": "^3.24.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.8.0"
+  }
+}

package/scripts/patch-roon-api.js

@@ -0,0 +1,45 @@
+/**
+ * Postinstall patch for node-roon-api.
+ *
+ * The ws library is an EventEmitter that emits 'error' events, but
+ * node-roon-api only sets DOM-style .onerror handlers on the WebSocket.
+ * This leaves EventEmitter 'error' events unhandled, which crashes Node.js.
+ *
+ * This script adds a proper .on('error', ...) listener to transport-websocket.js.
+ */
+
+import { readFileSync, writeFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const filePath = join(__dirname, "..", "node_modules", "node-roon-api", "transport-websocket.js");
+
+const PATCH_MARKER = "// [roon-mcp-patch] EventEmitter error handler";
+
+try {
+  let content = readFileSync(filePath, "utf8");
+
+  if (content.includes(PATCH_MARKER)) {
+    console.error("[patch] node-roon-api already patched, skipping.");
+    process.exit(0);
+  }
+
+  // Add .on('error', ...) right after the existing .on('pong', ...) line
+  const target = "this.ws.on('pong', () => this.is_alive = true);";
+  const replacement = `this.ws.on('pong', () => this.is_alive = true);
+    ${PATCH_MARKER}
+    this.ws.on('error', (err) => { if (this.onerror) this.onerror(err); });`;
+
+  if (!content.includes(target)) {
+    console.error("[patch] Could not find target line in transport-websocket.js. Skipping patch.");
+    process.exit(0);
+  }
+
+  content = content.replace(target, replacement);
+  writeFileSync(filePath, content, "utf8");
+  console.error("[patch] Patched node-roon-api transport-websocket.js: added EventEmitter error handler.");
+} catch (e) {
+  console.error("[patch] Failed to patch node-roon-api:", e.message);
+  // Non-fatal: the process.on('uncaughtException') handler in index.ts is a fallback
+}