roonpipe 1.0.0

package/LICENCE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ivo Šmerek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,174 @@
+# RoonPipe
+
+A Linux integration layer for [Roon](https://roonlabs.com/) that brings native desktop features like MPRIS support, media key controls, desktop notifications, and a powerful search CLI.
+
+![License](https://img.shields.io/badge/license-MIT-blue.svg)
+![Platform](https://img.shields.io/badge/platform-Linux-lightgrey.svg)
+
+## Features
+
+- **MPRIS Integration** — Control Roon playback using standard Linux media keys, `playerctl`, or any MPRIS-compatible application
+- **Desktop Notifications** — Get notified when tracks change, complete with album artwork
+- **Playback Controls** — Play, pause, stop, skip, seek, volume, shuffle, and loop
+- **Track Search** — Search your entire Roon library (including TIDAL/Qobuz) via CLI or programmatically
+- **Unix Socket API** — Integrate with other applications using a simple JSON-based IPC protocol
+- **Interactive CLI** — Search and play tracks directly from your terminal
+
+## CLI Example
+
+```
+🎵 RoonPipe Interactive Search
+==============================
+
+🔍 Search for a track: pink floyd
+
+Searching for "pink floyd"...
+
+Found 50 track(s):
+
+❯ Comfortably Numb · Pink Floyd · The Wall
+  Wish You Were Here · Pink Floyd · Wish You Were Here
+  Time · Pink Floyd · The Dark Side of the Moon
+  Another Brick in the Wall, Pt. 2 · Pink Floyd · The Wall
+  ────────────────────────────────────────
+  🔍 New search
+  ❌ Quit
+```
+
+## Requirements
+
+- Linux with D-Bus (for MPRIS)
+- Node.js 18+
+- Roon Core on your network
+- `libnotify` for desktop notifications (optional)
+
+## Installation
+
+### From npm (recommended)
+
+```bash
+npm install -g roonpipe
+```
+
+### From source
+
+```bash
+git clone https://github.com/BlueManCZ/roonpipe.git
+cd roonpipe
+pnpm install
+pnpm build
+```
+
+## Usage
+
+### Running the Daemon
+
+Start the daemon to enable MPRIS integration and the socket server:
+
+```bash
+roonpipe
+```
+
+Or if installed from source:
+
+```bash
+pnpm start
+```
+
+On first run, open Roon and authorize the "RoonPipe" extension in **Settings → Extensions**.
+
+### Interactive CLI
+
+Search and play tracks from your terminal:
+
+```bash
+roonpipe --cli
+```
+
+Or if installed from source:
+
+```bash
+pnpm run cli
+```
+
+Use arrow keys to navigate results and press Enter to play.
+
+### Development Mode
+
+Run with hot-reload during development:
+
+```bash
+pnpm dev
+```
+
+## MPRIS Controls
+
+Once the daemon is running, you can control Roon using standard tools:
+
+```bash
+# Basic controls
+playerctl -p roon play
+playerctl -p roon pause
+playerctl -p roon next
+playerctl -p roon previous
+
+# Volume
+playerctl -p roon volume 0.5
+
+# Seek (in seconds)
+playerctl -p roon position 30
+
+# Get current track info
+playerctl -p roon metadata
+```
+
+## Socket API
+
+RoonPipe exposes a Unix socket at `/tmp/roonpipe.sock` for IPC communication.
+
+### Search
+
+```bash
+echo '{"command":"search","query":"beatles"}' | nc -U /tmp/roonpipe.sock
+```
+
+Response:
+```json
+{
+  "results": [
+    {
+      "title": "Let It Be",
+      "subtitle": "The Beatles · Let It Be",
+      "item_key": "10:0",
+      "sessionKey": "search_1234567890"
+    }
+  ]
+}
+```
+
+### Play
+
+```bash
+echo '{"command":"play","item_key":"10:0","session_key":"search_1234567890"}' | nc -U /tmp/roonpipe.sock
+```
+
+## Project Structure
+
+```
+src/
+├── index.ts    # Entry point, daemon/CLI mode switching
+├── roon.ts     # Roon API connection and browsing
+├── mpris.ts    # MPRIS player, notifications, metadata
+├── socket.ts   # Unix socket server
+└── cli.ts      # Interactive terminal interface
+```
+
+## Contributing
+
+Contributions are welcome! Feel free to open issues or submit pull requests.
+
+## Acknowledgments
+
+- [Roon Labs](https://roonlabs.com/) for the amazing music player and API
+- [node-roon-api](https://github.com/roonlabs/node-roon-api) — Official Roon Node.js API
+- [mpris-service](https://github.com/dbusjs/mpris-service) — MPRIS implementation for Node.js

package/dist/cli.js

@@ -0,0 +1,152 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startCLI = startCLI;
+const node_net_1 = __importDefault(require("node:net"));
+const node_readline_1 = __importDefault(require("node:readline"));
+const prompts_1 = require("@inquirer/prompts");
+const SOCKET_PATH = "/tmp/roonpipe.sock";
+// Helper to send command to daemon via socket
+function sendCommand(command) {
+    return new Promise((resolve, reject) => {
+        const client = node_net_1.default.createConnection(SOCKET_PATH, () => {
+            client.write(JSON.stringify(command));
+        });
+        let data = "";
+        client.on("data", (chunk) => {
+            data += chunk.toString();
+        });
+        client.on("end", () => {
+            try {
+                const response = JSON.parse(data);
+                if (response.error) {
+                    reject(response.error);
+                }
+                else {
+                    resolve(response);
+                }
+            }
+            catch (_a) {
+                reject("Failed to parse response");
+            }
+        });
+        client.on("error", (err) => {
+            reject(`Cannot connect to RoonPipe daemon. Is it running?\n${err.message}`);
+        });
+    });
+}
+function searchQuery() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const rl = node_readline_1.default.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        return new Promise((resolve) => {
+            rl.question("🔍 Search for a track: ", (answer) => {
+                rl.close();
+                resolve(answer);
+            });
+        });
+    });
+}
+function search() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const query = yield searchQuery();
+        if (!query.trim()) {
+            return [];
+        }
+        console.log(`\nSearching for "${query}"...\n`);
+        try {
+            const response = yield sendCommand({ command: "search", query });
+            return response.results || [];
+        }
+        catch (error) {
+            console.error("❌ Error:", error);
+            return [];
+        }
+    });
+}
+function selectTrack(results) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const choices = [
+            ...results.map((result, index) => ({
+                name: `${result.title} ${result.subtitle ? `· ${result.subtitle}` : ""}`,
+                value: index,
+            })),
+            new prompts_1.Separator(),
+            { name: "🔍 New search", value: -1 },
+            { name: "❌ Quit", value: -2 },
+        ];
+        try {
+            const selection = yield (0, prompts_1.select)({
+                message: "Select a track to play:",
+                choices,
+                pageSize: 15,
+                theme: { prefix: "" },
+            });
+            if (selection === -2) {
+                return null;
+            }
+            if (selection === -1) {
+                return { item_key: "", sessionKey: "", title: "", subtitle: "__search__" };
+            }
+            return results[selection];
+        }
+        catch (_a) {
+            // User pressed Ctrl+C
+            return null;
+        }
+    });
+}
+function playTrack(track) {
+    return __awaiter(this, void 0, void 0, function* () {
+        console.log(`\n▶️ Playing: ${track.title}${track.subtitle ? ` · ${track.subtitle}` : ""}\n`);
+        try {
+            yield sendCommand({
+                command: "play",
+                item_key: track.item_key,
+                session_key: track.sessionKey,
+            });
+            console.log("✅ Playback started!\n");
+        }
+        catch (error) {
+            console.error("❌ Failed to play track:", error);
+        }
+    });
+}
+function startCLI() {
+    return __awaiter(this, void 0, void 0, function* () {
+        console.log("\n🎵 RoonPipe Interactive Search");
+        console.log("==============================\n");
+        let running = true;
+        while (running) {
+            const results = yield search();
+            if (results.length === 0) {
+                console.log("❌ No tracks found.\n");
+                continue;
+            }
+            console.log(`Found ${results.length} track(s):\n`);
+            const selected = yield selectTrack(results);
+            if (selected === null) {
+                console.log("\nGoodbye! 👋\n");
+                running = false;
+                continue;
+            }
+            if (selected.subtitle === "__search__") {
+                continue;
+            }
+            yield playTrack(selected);
+        }
+    });
+}

package/dist/index.js

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cli_1 = require("./cli");
+const mpris_1 = require("./mpris");
+const roon_1 = require("./roon");
+const socket_1 = require("./socket");
+// Check if CLI mode is requested
+const cliMode = process.argv.includes("--cli");
+if (cliMode) {
+    // CLI mode - just connect to daemon via socket
+    (0, cli_1.startCLI)();
+}
+else {
+    // Daemon mode - check for the existing instance
+    (0, socket_1.isInstanceRunning)().then((running) => {
+        if (running) {
+            console.error("❌  Another instance of RoonPipe is already running.");
+            console.error("   Stop the existing instance first, or use --cli to connect to it.");
+            process.exit(1);
+        }
+        // Daemon mode - start all services
+        console.log("Starting RoonPipe Daemon");
+        // Initialize MPRIS
+        (0, mpris_1.initMpris)(() => { var _a; return (_a = (0, roon_1.getCore)()) === null || _a === void 0 ? void 0 : _a.services.RoonApiTransport; }, roon_1.getZone);
+        // Initialize Roon and start socket server
+        (0, roon_1.initRoon)({
+            onCorePaired: (_core) => {
+                (0, socket_1.startSocketServer)({
+                    search: roon_1.searchRoon,
+                    play: roon_1.playItem,
+                });
+            },
+            onCoreUnpaired: (_core) => {
+                // Clear MPRIS metadata when unpaired
+                (0, mpris_1.updateMprisMetadata)(null, null);
+            },
+            onZoneChanged: (zone, core) => {
+                // Update MPRIS when zone changes
+                (0, mpris_1.updateMprisMetadata)(zone, core);
+            },
+            onSeekChanged: (seekPosition) => {
+                // Update MPRIS seek position
+                (0, mpris_1.updateMprisSeek)(seekPosition);
+            },
+        });
+    });
+}

package/dist/mpris.js

@@ -0,0 +1,215 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initMpris = initMpris;
+exports.updateMprisMetadata = updateMprisMetadata;
+exports.updateMprisSeek = updateMprisSeek;
+const node_fs_1 = __importDefault(require("node:fs"));
+// @ts-expect-error
+const mpris_service_1 = __importDefault(require("mpris-service"));
+const node_notifier_1 = __importDefault(require("node-notifier"));
+let mpris = null;
+let lastNotifiedTrack = null;
+let isInitialLoad = true;
+let lastPlaybackState = null;
+const artworkPath = "/tmp/roon-mpris-cover.jpg";
+const loopMap = {
+    // Roon -> MPRIS
+    loop_one: "Track",
+    loop: "Playlist",
+    disabled: "None",
+    next: "None",
+    // MPRIS -> Roon
+    Track: "loop_one",
+    Playlist: "loop",
+    None: "disabled",
+};
+function convertRoonLoopToMPRIS(roonLoop) {
+    return loopMap[roonLoop] || "None";
+}
+function convertMPRISLoopToRoon(mprisLoop) {
+    return loopMap[mprisLoop] || "disabled";
+}
+function initMpris(getTransport, getZone) {
+    // Helper to call Roon transport functions
+    function roonCallback(fn) {
+        const transport = getTransport();
+        const zone = getZone();
+        if (transport && zone) {
+            fn(transport, zone);
+        }
+    }
+    mpris = (0, mpris_service_1.default)({
+        name: "roon",
+        identity: "Roon",
+        supportedUriSchemes: ["file"],
+        supportedMimeTypes: ["audio/mpeg", "application/ogg"],
+        supportedInterfaces: ["player"],
+    });
+    // Wire up all MPRIS events
+    const events = [
+        "play",
+        "pause",
+        "stop",
+        "playpause",
+        "next",
+        "previous",
+        "seek",
+        "position",
+        "volume",
+        "loopStatus",
+        "shuffle",
+        "open",
+    ];
+    events.forEach((event) => {
+        mpris.on(event, (data) => {
+            switch (event) {
+                case "seek":
+                    roonCallback((t, z) => t.seek(z, "relative", data / 1000000));
+                    break;
+                case "position":
+                    roonCallback((t, z) => t.seek(z, "absolute", data.position / 1000000));
+                    break;
+                case "volume":
+                    roonCallback((t, z) => {
+                        var _a, _b;
+                        if (!((_b = (_a = z.outputs) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.volume))
+                            return;
+                        const output = z.outputs[0];
+                        const vol = output.volume;
+                        const roonVolume = vol.min + data * (vol.max - vol.min);
+                        t.change_volume(output, "absolute", Math.round(roonVolume));
+                    });
+                    break;
+                case "loopStatus":
+                    roonCallback((t, z) => t.change_settings(z, { loop: convertMPRISLoopToRoon(data) }));
+                    break;
+                case "shuffle":
+                    roonCallback((t, z) => t.change_settings(z, { shuffle: data }));
+                    break;
+                case "open":
+                    console.log("MPRIS command: open", data.uri);
+                    break;
+                default:
+                    roonCallback((t, z) => t.control(z, event));
+                    break;
+            }
+        });
+    });
+    // Position getter - dynamically reads from zone
+    mpris.getPosition = () => {
+        var _a;
+        const zone = getZone();
+        return ((_a = zone === null || zone === void 0 ? void 0 : zone.now_playing) === null || _a === void 0 ? void 0 : _a.seek_position) ? zone.now_playing.seek_position * 1000000 : 0;
+    };
+    // Set initial states
+    mpris.canControl = true;
+    mpris.canPlay = true;
+    mpris.canPause = true;
+    mpris.canGoNext = true;
+    mpris.canGoPrevious = true;
+    mpris.canSeek = true;
+    mpris.playbackStatus = "Stopped";
+    console.log("MPRIS player initialized");
+}
+function fetchArtwork(core, imageKey, callback) {
+    const image = core.services.RoonApiImage;
+    image.get_image(imageKey, { scale: "fit", width: 256, height: 256, format: "image/jpeg" }, (error, _contentType, imageData) => {
+        if (error) {
+            console.error("Failed to fetch artwork:", error);
+            return;
+        }
+        node_fs_1.default.writeFileSync(artworkPath, imageData);
+        console.log("Artwork saved to", artworkPath);
+        callback();
+    });
+}
+function showTrackNotification(zone) {
+    var _a, _b, _c;
+    if (!zone || !zone.now_playing)
+        return;
+    const np = zone.now_playing;
+    const trackId = np.image_key || "";
+    const currentState = zone.state;
+    // Skip notification on an initial load
+    if (isInitialLoad) {
+        lastNotifiedTrack = trackId;
+        lastPlaybackState = currentState;
+        isInitialLoad = false;
+        return;
+    }
+    // Show notification if the track changed or started playing
+    const trackChanged = trackId !== lastNotifiedTrack;
+    const startedPlaying = currentState === "playing" && lastPlaybackState !== "playing";
+    if (trackChanged || startedPlaying) {
+        lastNotifiedTrack = trackId;
+        node_notifier_1.default.notify({
+            title: ((_a = np.three_line) === null || _a === void 0 ? void 0 : _a.line1) || "Unknown Track",
+            message: `${((_b = np.three_line) === null || _b === void 0 ? void 0 : _b.line2) || "Unknown Artist"}\n${((_c = np.three_line) === null || _c === void 0 ? void 0 : _c.line3) || ""}`,
+            timeout: 5,
+            icon: artworkPath,
+            hint: "string:x-canonical-private-synchronous:roonpipe",
+        });
+    }
+    lastPlaybackState = currentState;
+}
+function updateVolume(zone) {
+    if (!mpris)
+        return;
+    if (!zone || !zone.outputs || zone.outputs.length === 0) {
+        mpris.volume = 0;
+        return;
+    }
+    const output = zone.outputs[0];
+    if (!output.volume) {
+        mpris.volume = 0;
+        return;
+    }
+    const vol = output.volume;
+    mpris.volume = (vol.value - vol.min) / (vol.max - vol.min);
+}
+function updateMprisMetadata(zone, core) {
+    var _a, _b, _c;
+    if (!mpris)
+        return;
+    if (!zone || !zone.now_playing) {
+        mpris.metadata = {};
+        return;
+    }
+    const np = zone.now_playing;
+    // Fetch artwork if image_key exists
+    if (np.image_key) {
+        fetchArtwork(core, np.image_key, () => {
+            showTrackNotification(zone);
+        });
+    }
+    mpris.metadata = {
+        "mpris:trackid": mpris.objectPath(`track/${np.image_key || "0"}`),
+        "xesam:title": ((_a = np.three_line) === null || _a === void 0 ? void 0 : _a.line1) || "Unknown",
+        "xesam:artist": ((_b = np.three_line) === null || _b === void 0 ? void 0 : _b.line2) ? [np.three_line.line2] : [],
+        "xesam:album": ((_c = np.three_line) === null || _c === void 0 ? void 0 : _c.line3) || "",
+        "mpris:length": (np.length || 0) * 1000000,
+        "mpris:artUrl": `file://${artworkPath}`,
+    };
+    // For playpause to work, we need canPlay OR canPause to be true
+    // When playing: is_pause_allowed=true, is_play_allowed=false
+    // When paused: is_pause_allowed=false, is_play_allowed=true
+    // We set both to true if either action is allowed, so playpause always works
+    const canTogglePlayback = zone.is_play_allowed || zone.is_pause_allowed;
+    mpris.canPlay = canTogglePlayback;
+    mpris.canPause = canTogglePlayback;
+    mpris.canGoNext = zone.is_next_allowed;
+    mpris.canGoPrevious = zone.is_previous_allowed;
+    mpris.playbackStatus = zone.state === "playing" ? "Playing" : "Paused";
+    mpris.loopStatus = convertRoonLoopToMPRIS(zone.settings.loop);
+    mpris.shuffle = zone.settings.shuffle;
+    mpris.canSeek = zone.is_seek_allowed;
+    updateVolume(zone);
+}
+function updateMprisSeek(seekPosition) {
+    if (!mpris)
+        return;
+    mpris.seeked(seekPosition);
+}

package/dist/roon.js

@@ -0,0 +1,216 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initRoon = initRoon;
+exports.searchRoon = searchRoon;
+exports.playItem = playItem;
+exports.getZone = getZone;
+exports.getCore = getCore;
+// @ts-expect-error
+const node_roon_api_1 = __importDefault(require("node-roon-api"));
+// @ts-expect-error
+const node_roon_api_browse_1 = __importDefault(require("node-roon-api-browse"));
+// @ts-expect-error
+const node_roon_api_image_1 = __importDefault(require("node-roon-api-image"));
+// @ts-expect-error
+const node_roon_api_transport_1 = __importDefault(require("node-roon-api-transport"));
+let zone = null;
+let coreInstance = null;
+function initRoon(callbacks) {
+    const roon = new node_roon_api_1.default({
+        extension_id: "com.bluemancz.roonpipe",
+        display_name: "RoonPipe",
+        display_version: "1.0.0",
+        publisher: "BlueManCZ",
+        email: "your@email.com",
+        website: "https://github.com/bluemancz/roonpipe",
+        core_paired: (core) => {
+            coreInstance = core;
+            const transport = core.services.RoonApiTransport;
+            transport.subscribe_zones((cmd, data) => {
+                if (cmd === "Subscribed") {
+                    zone = data.zones.find((z) => z.state === "playing") || data.zones[0];
+                    callbacks.onZoneChanged(zone, core);
+                }
+                else if (cmd === "Changed") {
+                    if (data.zones_changed) {
+                        const playingZone = data.zones_changed.find((z) => z.state === "playing");
+                        if (playingZone) {
+                            zone = playingZone;
+                        }
+                        else if (zone) {
+                            zone =
+                                data.zones_changed.find((z) => z.zone_id === zone.zone_id) ||
+                                    zone;
+                        }
+                        callbacks.onZoneChanged(zone, core);
+                    }
+                    if (data.zones_seek_changed) {
+                        const seekUpdate = data.zones_seek_changed.find((z) => z.zone_id === (zone === null || zone === void 0 ? void 0 : zone.zone_id));
+                        if (seekUpdate && zone) {
+                            zone.now_playing.seek_position = seekUpdate.seek_position;
+                            callbacks.onSeekChanged(seekUpdate.seek_position * 1000000);
+                        }
+                    }
+                }
+            });
+            callbacks.onCorePaired(core);
+            console.log(`Core paired: ${core.display_name}`);
+        },
+        core_unpaired: (core) => {
+            zone = null;
+            coreInstance = null;
+            callbacks.onCoreUnpaired(core);
+            console.log(`Core unpaired: ${core.display_name}`);
+        },
+    });
+    roon.init_services({
+        required_services: [node_roon_api_browse_1.default, node_roon_api_image_1.default, node_roon_api_transport_1.default],
+    });
+    roon.start_discovery();
+}
+function searchRoon(query) {
+    return new Promise((resolve, reject) => {
+        if (!coreInstance) {
+            reject("Roon Core not connected");
+            return;
+        }
+        if (!zone) {
+            reject("No active zone");
+            return;
+        }
+        const browse = coreInstance.services.RoonApiBrowse;
+        const sessionKey = `search_${Date.now()}`;
+        const opts = {
+            hierarchy: "search",
+            input: query,
+            multi_session_key: sessionKey,
+            zone_or_output_id: zone.zone_id,
+        };
+        browse.browse(opts, (error, result) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            browse.load(Object.assign(Object.assign({}, opts), { offset: 0, count: result.list.count }), (loadError, loadResult) => {
+                var _a;
+                if (loadError) {
+                    reject(loadError);
+                    return;
+                }
+                const tracksCategory = (_a = loadResult.items) === null || _a === void 0 ? void 0 : _a.find((item) => item.title === "Tracks");
+                if (!tracksCategory) {
+                    // No tracks category found - return empty array
+                    resolve([]);
+                    return;
+                }
+                browse.browse(Object.assign(Object.assign({}, opts), { item_key: tracksCategory.item_key }), (browseError, browseResult) => {
+                    if (browseError) {
+                        reject(browseError);
+                        return;
+                    }
+                    browse.load(Object.assign(Object.assign({}, opts), { item_key: tracksCategory.item_key, offset: 0, count: Math.min(browseResult.list.count, 50) }), (tracksError, tracksResult) => {
+                        var _a;
+                        if (tracksError) {
+                            reject(tracksError);
+                            return;
+                        }
+                        const items = ((_a = tracksResult.items) === null || _a === void 0 ? void 0 : _a.map((item) => ({
+                            title: item.title || "Unknown",
+                            subtitle: item.subtitle || "",
+                            item_key: item.item_key,
+                            image_key: item.image_key,
+                            hint: item.hint,
+                            sessionKey: sessionKey,
+                        }))) || [];
+                        resolve(items);
+                    });
+                });
+            });
+        });
+    });
+}
+function playItem(itemKey, sessionKey) {
+    return new Promise((resolve, reject) => {
+        if (!coreInstance) {
+            reject("Roon Core not connected");
+            return;
+        }
+        if (!zone) {
+            reject("No active zone");
+            return;
+        }
+        const browse = coreInstance.services.RoonApiBrowse;
+        function loadUntilAction(currentItemKey, depth = 0) {
+            if (depth > 5) {
+                reject("Too many levels, cannot find action");
+                return;
+            }
+            browse.browse({
+                hierarchy: "search",
+                multi_session_key: sessionKey,
+                item_key: currentItemKey,
+                zone_or_output_id: zone.zone_id,
+            }, (browseError, browseResult) => {
+                var _a;
+                if (browseError) {
+                    reject(browseError);
+                    return;
+                }
+                browse.load({
+                    hierarchy: "search",
+                    multi_session_key: sessionKey,
+                    item_key: currentItemKey,
+                    offset: 0,
+                    count: ((_a = browseResult.list) === null || _a === void 0 ? void 0 : _a.count) || 10,
+                    zone_or_output_id: zone.zone_id,
+                }, (loadError, loadResult) => {
+                    if (loadError) {
+                        reject(loadError);
+                        return;
+                    }
+                    if (!loadResult.items || loadResult.items.length === 0) {
+                        reject("No items found");
+                        return;
+                    }
+                    const playNowAction = loadResult.items.find((item) => item.hint === "action" &&
+                        (item.title === "Play Now" || item.title === "Play"));
+                    if (playNowAction) {
+                        browse.browse({
+                            hierarchy: "search",
+                            multi_session_key: sessionKey,
+                            item_key: playNowAction.item_key,
+                            zone_or_output_id: zone.zone_id,
+                        }, (playError) => {
+                            if (playError) {
+                                reject(playError);
+                            }
+                            else {
+                                console.log("Successfully started playback");
+                                resolve();
+                            }
+                        });
+                    }
+                    else {
+                        const actionList = loadResult.items.find((item) => item.hint === "action_list");
+                        if (actionList) {
+                            loadUntilAction(actionList.item_key, depth + 1);
+                        }
+                        else {
+                            reject("Could not find Play action or next level");
+                        }
+                    }
+                });
+            });
+        }
+        loadUntilAction(itemKey);
+    });
+}
+function getZone() {
+    return zone;
+}
+function getCore() {
+    return coreInstance;
+}

package/dist/socket.js

@@ -0,0 +1,97 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isInstanceRunning = isInstanceRunning;
+exports.startSocketServer = startSocketServer;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_net_1 = __importDefault(require("node:net"));
+const SOCKET_PATH = "/tmp/roonpipe.sock";
+let socketServer = null;
+/**
+ * Check if another instance is already running by trying to connect to the socket
+ */
+function isInstanceRunning() {
+    return new Promise((resolve) => {
+        if (!node_fs_1.default.existsSync(SOCKET_PATH)) {
+            resolve(false);
+            return;
+        }
+        const client = node_net_1.default.createConnection({ path: SOCKET_PATH }, () => {
+            // Connection successful - another instance is running
+            client.end();
+            resolve(true);
+        });
+        client.on("error", () => {
+            // Connection failed - socket is stale, no instance running
+            resolve(false);
+        });
+        // Timeout after 1 second
+        client.setTimeout(1000, () => {
+            client.destroy();
+            resolve(false);
+        });
+    });
+}
+function startSocketServer(handlers) {
+    // Remove old socket if exists
+    if (node_fs_1.default.existsSync(SOCKET_PATH)) {
+        node_fs_1.default.unlinkSync(SOCKET_PATH);
+    }
+    socketServer = node_net_1.default.createServer((client) => {
+        console.log("Client connected to socket");
+        client.on("data", (data) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const request = JSON.parse(data.toString());
+                console.log("Received request:", request);
+                if (request.command === "search") {
+                    try {
+                        const results = yield handlers.search(request.query);
+                        client.write(`${JSON.stringify({ error: null, results })}\n`);
+                    }
+                    catch (error) {
+                        client.write(`${JSON.stringify({ error: String(error), results: null })}\n`);
+                    }
+                    client.end();
+                }
+                else if (request.command === "play") {
+                    try {
+                        yield handlers.play(request.item_key, request.session_key);
+                        client.write(`${JSON.stringify({ error: null, success: true })}\n`);
+                    }
+                    catch (error) {
+                        client.write(`${JSON.stringify({ error: String(error), success: false })}\n`);
+                    }
+                    client.end();
+                }
+                else {
+                    client.write(`${JSON.stringify({ error: "Unknown command" })}\n`);
+                    client.end();
+                }
+            }
+            catch (e) {
+                console.error("Socket error:", e);
+                client.write(`${JSON.stringify({ error: "Invalid request format" })}\n`);
+                client.end();
+            }
+        }));
+        client.on("error", (err) => {
+            console.error("Client error:", err);
+        });
+    });
+    socketServer.listen(SOCKET_PATH, () => {
+        console.log("Unix socket server listening on", SOCKET_PATH);
+        // Set permissions so any user can connect
+        node_fs_1.default.chmodSync(SOCKET_PATH, 0o666);
+    });
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "roonpipe",
+  "version": "1.0.0",
+  "description": "Linux integration for Roon – MPRIS support, media keys, desktop notifications, and interactive search CLI",
+  "main": "dist/index.js",
+  "bin": {
+    "roonpipe": "dist/index.js"
+  },
+  "keywords": [
+    "roon",
+    "mpris",
+    "linux",
+    "media-player",
+    "tidal",
+    "qobuz"
+  ],
+  "author": "Ivo Šmerek",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/BlueManCZ/roonpipe.git"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.3.11",
+    "@types/node-notifier": "^8.0.5",
+    "nodemon": "^3.1.11",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.5.3"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@inquirer/prompts": "^8.2.0",
+    "mpris-service": "^2.1.2",
+    "node-notifier": "^10.0.1",
+    "node-roon-api": "github:roonlabs/node-roon-api",
+    "node-roon-api-browse": "github:roonlabs/node-roon-api-browse",
+    "node-roon-api-image": "github:roonlabs/node-roon-api-image",
+    "node-roon-api-transport": "github:roonlabs/node-roon-api-transport"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "nodemon src/index.ts",
+    "cli": "tsc && node dist/index.js --cli"
+  }
+}