iobroker.squeezeboxrpc 2.0.2 → 3.0.0

package/lib/lms/jsonRpcClient.js

@@ -0,0 +1,139 @@
+'use strict';
+/* eslint-disable jsdoc/require-jsdoc */
+
+const http = require('node:http');
+const https = require('node:https');
+
+const DEFAULT_TIMEOUT_MS = 10_000;
+const MAX_RESPONSE_BYTES = 16 * 1024 * 1024;
+
+/**
+ * Minimal LMS HTTP JSON-RPC client.
+ *
+ * The callback response intentionally keeps the shape used by the adapter
+ * while the adapter call sites are migrated to promises independently.
+ */
+class LmsJsonRpcClient {
+    constructor({ host, port, username = '', password = '', protocol = 'http:', timeoutMs = DEFAULT_TIMEOUT_MS }) {
+        this.url = new URL('/jsonrpc.js', `${protocol}//${host}:${port}`);
+        this.timeoutMs = timeoutMs;
+        this.nextRequestId = 1;
+        this.closed = false;
+        this.authorization =
+            username && password ? `Basic ${Buffer.from(`${username}:${password}`).toString('base64')}` : '';
+        this.agent =
+            this.url.protocol === 'https:'
+                ? new https.Agent({ keepAlive: true, maxSockets: 8 })
+                : new http.Agent({ keepAlive: true, maxSockets: 8 });
+    }
+
+    request(playerId, command, callback) {
+        const promise = this.requestAsync(playerId, command);
+        if (callback) {
+            promise.then(callback, error => callback(this.toLegacyError(error)));
+        }
+        return promise;
+    }
+
+    requestAsync(playerId, command) {
+        if (this.closed) {
+            return Promise.reject(new Error('LMS JSON-RPC client is closed'));
+        }
+        if (!Array.isArray(command)) {
+            return Promise.reject(new TypeError('LMS command must be an array'));
+        }
+
+        const params = [playerId || '', command];
+        const payload = JSON.stringify({
+            id: `squeezeboxrpc.${process.pid}.${this.nextRequestId++}`,
+            method: 'slim.request',
+            params,
+        });
+
+        return new Promise((resolve, reject) => {
+            const transport = this.url.protocol === 'https:' ? https : http;
+            const headers = {
+                Accept: 'application/json',
+                'Content-Type': 'application/json',
+                'Content-Length': Buffer.byteLength(payload),
+            };
+            if (this.authorization) {
+                headers.Authorization = this.authorization;
+            }
+
+            const request = transport.request(
+                this.url,
+                {
+                    method: 'POST',
+                    agent: this.agent,
+                    headers,
+                },
+                response => {
+                    const chunks = [];
+                    let responseBytes = 0;
+
+                    response.on('data', chunk => {
+                        responseBytes += chunk.length;
+                        if (responseBytes > MAX_RESPONSE_BYTES) {
+                            request.destroy(new Error('LMS JSON-RPC response is too large'));
+                            return;
+                        }
+                        chunks.push(chunk);
+                    });
+                    response.on('end', () => {
+                        const statusCode = response.statusCode || 0;
+                        if (statusCode < 200 || statusCode >= 300) {
+                            reject(new Error(`LMS JSON-RPC HTTP status ${statusCode || 'unknown'}`));
+                            return;
+                        }
+
+                        const body = Buffer.concat(chunks).toString('utf8');
+                        if (!body) {
+                            reject(new Error('LMS JSON-RPC returned an empty response'));
+                            return;
+                        }
+
+                        let reply;
+                        try {
+                            reply = JSON.parse(body);
+                        } catch (error) {
+                            reject(new Error(`Invalid LMS JSON-RPC response: ${error.message}`, { cause: error }));
+                            return;
+                        }
+
+                        if (reply.error) {
+                            const message = reply.error.message || reply.error.data || String(reply.error);
+                            reject(new Error(`LMS JSON-RPC error: ${message}`));
+                            return;
+                        }
+                        if (!Object.prototype.hasOwnProperty.call(reply, 'result')) {
+                            reject(new Error('LMS JSON-RPC response has no result'));
+                            return;
+                        }
+
+                        resolve({ ...reply, params: reply.params || params, ok: true });
+                    });
+                },
+            );
+
+            request.setTimeout(this.timeoutMs, () => request.destroy(new Error('LMS JSON-RPC request timed out')));
+            request.on('error', reject);
+            request.end(payload);
+        });
+    }
+
+    toLegacyError(error) {
+        return {
+            ok: false,
+            message: error instanceof Error ? error.message : String(error || 'Unknown LMS JSON-RPC error'),
+            error,
+        };
+    }
+
+    close() {
+        this.closed = true;
+        this.agent.destroy();
+    }
+}
+
+module.exports = { LmsJsonRpcClient };

package/lib/lms/telnetEventClient.js

@@ -0,0 +1,122 @@
+'use strict';
+
+const net = require('node:net');
+
+const PLAYER_EVENT = /^((?:[0-9A-Fa-f]{2}[:-]){5}(?:[0-9A-Fa-f]{2}))\s*(.*)$/;
+
+/**
+ * Decodes one LMS CLI response line without allowing malformed URI escapes to
+ * terminate the event connection.
+ *
+ * @param {string} line Raw LMS CLI line.
+ * @returns {string} Decoded line, or the original line when decoding fails.
+ */
+function decodeLine(line) {
+    try {
+        return decodeURIComponent(line);
+    } catch {
+        return line;
+    }
+}
+
+/**
+ * Parses one LMS CLI notification.
+ *
+ * @param {string} line Raw LMS CLI line.
+ * @returns {{ playerId: string, command: string } | null} Parsed player event.
+ */
+function parsePlayerEvent(line) {
+    const match = PLAYER_EVENT.exec(decodeLine(line));
+    if (!match) {
+        return null;
+    }
+    return { playerId: match[1], command: match[2].trim() };
+}
+
+/** LMS CLI notification connection used alongside the JSON-RPC client. */
+class LmsTelnetEventClient {
+    /**
+     * @param {object} options Client options.
+     * @param {string} options.host LMS host.
+     * @param {number} options.port LMS CLI port.
+     * @param {string} [options.username] LMS username.
+     * @param {string} [options.password] LMS password.
+     * @param {(event: { playerId: string, command: string }) => void} options.onEvent Event callback.
+     * @param {(message: string) => void} [options.logDebug] Debug logger.
+     * @param {(options: object, listener: () => void) => import('node:net').Socket} [options.socketFactory]
+     * Socket factory used by tests.
+     */
+    constructor(options) {
+        this.host = options.host;
+        this.port = options.port;
+        this.username = options.username || '';
+        this.password = options.password || '';
+        this.onEvent = options.onEvent;
+        this.logDebug = options.logDebug || (() => undefined);
+        this.socketFactory = options.socketFactory || net.createConnection;
+        this.socket = null;
+        this.receiveBuffer = '';
+    }
+
+    /** Opens the LMS CLI connection and enables notification delivery. */
+    start() {
+        if (this.socket) {
+            return;
+        }
+
+        const socket = this.socketFactory({ host: this.host, port: this.port }, () => {
+            this.logDebug('Telnet event client connected to LMS');
+            if (this.username || this.password) {
+                socket.write(`login ${this.username} ${this.password}\r\n`);
+            }
+            socket.write('listen 1\r\n');
+        });
+        this.socket = socket;
+
+        socket.on('data', data => this.#handleData(data));
+        socket.on('end', () => this.logDebug('Telnet event client disconnected from LMS'));
+        socket.on('timeout', () => {
+            this.logDebug('Telnet event client timed out, closing socket');
+            socket.destroy();
+        });
+        socket.on('error', error => this.logDebug(`Telnet event client socket error: ${error.message}`));
+        socket.on('close', hadError => {
+            this.logDebug(`Telnet event client socket closed${hadError ? ' after an error' : ''}`);
+            if (this.socket === socket) {
+                this.socket = null;
+            }
+            this.receiveBuffer = '';
+        });
+    }
+
+    /**
+     * @param {Buffer|string} data Incoming TCP data.
+     */
+    #handleData(data) {
+        const chunk = data.toString();
+        this.logDebug(`Telnet event client received data: ${chunk}`);
+        this.receiveBuffer += chunk;
+
+        let lineEnd;
+        while ((lineEnd = this.receiveBuffer.indexOf('\n')) !== -1) {
+            const line = this.receiveBuffer.slice(0, lineEnd).replace(/\r$/, '');
+            this.receiveBuffer = this.receiveBuffer.slice(lineEnd + 1);
+            const event = parsePlayerEvent(line);
+            if (event) {
+                this.onEvent(event);
+            }
+        }
+    }
+
+    /** Ends the LMS CLI connection. Safe to call more than once. */
+    close() {
+        const socket = this.socket;
+        this.socket = null;
+        this.receiveBuffer = '';
+        if (socket && !socket.destroyed) {
+            socket.end();
+        }
+    }
+}
+
+module.exports = { LmsTelnetEventClient, parsePlayerEvent };

package/lib/lms/webSocketClient.js

@@ -0,0 +1,352 @@
+'use strict';
+
+const WebSocket = require('ws');
+
+const DEFAULT_TIMEOUT_MS = 10_000;
+const DEFAULT_RECONNECT_MS = 3_000;
+const ERROR_LOG_INTERVAL_MS = 60_000;
+const LIST_PAGE_SIZE = 100;
+const PAGED_COMMANDS = new Set([
+    'albums',
+    'artists',
+    'favorites',
+    'genres',
+    'menu',
+    'musicfolder',
+    'myapps',
+    'playlists',
+    'radios',
+    'songs',
+    'titles',
+    'tracks',
+    'works',
+    'years',
+]);
+
+/**
+ * Builds the WebSocket endpoint from an optional independent web-server URL.
+ * HTTP(S) URLs are accepted for convenient configuration and converted to
+ * WS(S). A root path is completed with the LMS plugin endpoint `/ws`.
+ *
+ * @param {object} options Client options.
+ * @param {string} options.host LMS host.
+ * @param {number} options.port LMS HTTP port.
+ * @param {string} [options.webSocketUrl] Independent WebSocket web-server URL.
+ * @returns {URL} Normalized WebSocket endpoint.
+ */
+function createWebSocketUrl(options) {
+    let configuredUrl = options.webSocketUrl?.trim();
+    if (!configuredUrl) {
+        return new URL('/ws', `ws://${options.host}:${options.port}`);
+    }
+    if (!/^[a-z][a-z\d+.-]*:\/\//i.test(configuredUrl)) {
+        configuredUrl = `ws://${configuredUrl}`;
+    }
+    const url = new URL(configuredUrl);
+    if (url.protocol === 'http:') {
+        url.protocol = 'ws:';
+    } else if (url.protocol === 'https:') {
+        url.protocol = 'wss:';
+    } else if (url.protocol !== 'ws:' && url.protocol !== 'wss:') {
+        throw new Error('LMS WebSocket URL must use HTTP(S) or WS(S)');
+    }
+    if (url.pathname === '/') {
+        url.pathname = '/ws';
+    }
+    return url;
+}
+
+/** Experimental LMS WebSocket command and notification client. */
+class LmsWebSocketClient {
+    /**
+     * @param {object} options Client options.
+     * @param {string} options.host LMS host.
+     * @param {number} options.port LMS HTTP/WebSocket port.
+     * @param {string} [options.username] LMS username.
+     * @param {string} [options.password] LMS password.
+     * @param {string} [options.webSocketUrl] Independent WebSocket URL.
+     * @param {(event: {playerId: string, command: string, data: object}) => void} [options.onEvent]
+     * Notification callback.
+     * @param {(message: string) => void} [options.logDebug] Debug logger.
+     * @param {(message: string) => void} [options.logError] Error logger.
+     * @param {number} [options.timeoutMs] Request timeout.
+     * @param {number} [options.reconnectMs] Reconnect delay.
+     * @param {typeof setTimeout} [options.setTimeout] Adapter-managed timer creator.
+     * @param {typeof clearTimeout} [options.clearTimeout] Adapter-managed timer cleanup.
+     * @param {typeof WebSocket} [options.webSocketClass] WebSocket implementation used by tests.
+     */
+    constructor(options) {
+        this.url = createWebSocketUrl(options);
+        this.origin = `${this.url.protocol === 'wss:' ? 'https:' : 'http:'}//${this.url.host}`;
+        this.username = options.username || '';
+        this.password = options.password || '';
+        this.onEvent = options.onEvent || (() => undefined);
+        this.logDebug = options.logDebug || (() => undefined);
+        this.logError = options.logError || this.logDebug;
+        this.timeoutMs = options.timeoutMs || DEFAULT_TIMEOUT_MS;
+        this.reconnectMs = options.reconnectMs || DEFAULT_RECONNECT_MS;
+        this.setTimeout = options.setTimeout || global.setTimeout;
+        this.clearTimeout = options.clearTimeout || global.clearTimeout;
+        this.WebSocketClass = options.webSocketClass || WebSocket;
+        this.socket = null;
+        this.connectPromise = null;
+        this.reconnectTimer = null;
+        this.nextRequestId = 1;
+        this.pendingRequests = new Map();
+        this.closed = false;
+        this.lastErrorLog = 0;
+    }
+
+    /** Starts connecting. Commands also connect lazily when necessary. */
+    start() {
+        void this.#ensureConnected().catch(error => this.#reportConnectionError(error));
+    }
+
+    /**
+     * Sends an LMS command and optionally reports the result through a callback.
+     *
+     * @param {string} playerId LMS player ID, or an empty string for server commands.
+     * @param {unknown[]} command LMS command tokens.
+     * @param {(result: object) => void} [callback] Compatibility callback.
+     * @returns {Promise<object>} Pending command result.
+     */
+    request(playerId, command, callback) {
+        const promise = this.requestAsync(playerId, command);
+        if (callback) {
+            promise.then(callback, error => callback(this.#toLegacyError(error)));
+        }
+        return promise;
+    }
+
+    /**
+     * Sends an LMS command over the WebSocket plugin endpoint.
+     *
+     * @param {string} playerId LMS player ID, or an empty string for server commands.
+     * @param {unknown[]} command LMS command tokens.
+     * @returns {Promise<object>} Pending command result.
+     */
+    async requestAsync(playerId, command) {
+        if (!Array.isArray(command)) {
+            throw new TypeError('LMS command must be an array');
+        }
+        const rangeIndex = this.#findLargeRange(command);
+        if (rangeIndex !== -1) {
+            return this.#requestPaged(playerId, command, rangeIndex);
+        }
+        return this.#requestSingle(playerId, command);
+    }
+
+    async #requestSingle(playerId, command) {
+        const socket = await this.#ensureConnected();
+        const id = this.nextRequestId++;
+        const params = [playerId || '', command];
+
+        return new Promise((resolve, reject) => {
+            const timeout = this.setTimeout(() => {
+                this.pendingRequests.delete(id);
+                reject(new Error('LMS WebSocket request timed out'));
+            }, this.timeoutMs);
+            this.pendingRequests.set(id, { resolve, reject, timeout, params });
+            try {
+                socket.send(JSON.stringify({ id, request: params }));
+            } catch (error) {
+                this.clearTimeout(timeout);
+                this.pendingRequests.delete(id);
+                reject(error);
+            }
+        });
+    }
+
+    #findLargeRange(command) {
+        if (!PAGED_COMMANDS.has(String(command[0]))) {
+            return -1;
+        }
+        for (let index = 1; index < Math.min(command.length - 1, 4); index++) {
+            const start = Number(command[index]);
+            const count = Number(command[index + 1]);
+            if (Number.isInteger(start) && start >= 0 && Number.isInteger(count) && count > LIST_PAGE_SIZE) {
+                return index;
+            }
+        }
+        return -1;
+    }
+
+    async #requestPaged(playerId, command, rangeIndex) {
+        const originalStart = Number(command[rangeIndex]);
+        const requestedCount = Number(command[rangeIndex + 1]);
+        let offset = originalStart;
+        let combined;
+        let loopKey;
+
+        while (offset - originalStart < requestedCount) {
+            const pageCommand = [...command];
+            pageCommand[rangeIndex] = offset;
+            pageCommand[rangeIndex + 1] = Math.min(LIST_PAGE_SIZE, requestedCount - (offset - originalStart));
+            const page = await this.#requestSingle(playerId, pageCommand);
+            const pageResult = page.result;
+            const currentLoopKey = Object.keys(pageResult).find(
+                key => key.endsWith('_loop') && Array.isArray(pageResult[key]),
+            );
+
+            if (!combined) {
+                combined = { ...page, result: { ...pageResult }, params: [playerId || '', command] };
+                loopKey = currentLoopKey;
+                if (loopKey) {
+                    combined.result[loopKey] = [...pageResult[loopKey]];
+                }
+            } else if (loopKey && currentLoopKey === loopKey) {
+                combined.result[loopKey].push(...pageResult[loopKey]);
+            }
+
+            const received = currentLoopKey ? pageResult[currentLoopKey].length : 0;
+            offset += received;
+            if (!currentLoopKey || received < pageCommand[rangeIndex + 1]) {
+                break;
+            }
+        }
+        return combined;
+    }
+
+    /** Permanently closes this client and rejects pending commands. */
+    close() {
+        this.closed = true;
+        if (this.reconnectTimer) {
+            this.clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        this.#rejectPending(new Error('LMS WebSocket client is closed'));
+        const socket = this.socket;
+        this.socket = null;
+        this.connectPromise = null;
+        if (socket && socket.readyState !== WebSocket.CLOSED) {
+            socket.close();
+        }
+    }
+
+    async #ensureConnected() {
+        if (this.closed) {
+            throw new Error('LMS WebSocket client is closed');
+        }
+        if (this.socket?.readyState === WebSocket.OPEN) {
+            return this.socket;
+        }
+        if (this.connectPromise) {
+            return this.connectPromise;
+        }
+
+        this.connectPromise = new Promise((resolve, reject) => {
+            const headers = {};
+            if (this.username && this.password) {
+                headers.Authorization = `Basic ${Buffer.from(`${this.username}:${this.password}`).toString('base64')}`;
+            }
+            const socket = new this.WebSocketClass(this.url, { headers, origin: this.origin });
+            this.socket = socket;
+            let settled = false;
+
+            socket.once('open', () => {
+                settled = true;
+                this.connectPromise = null;
+                this.lastErrorLog = 0;
+                this.logDebug('Connected to LMS WebSocket');
+                socket.send(JSON.stringify({ id: this.nextRequestId++, listen: 1 }));
+                resolve(socket);
+            });
+            socket.on('message', data => this.#handleMessage(data));
+            socket.once('error', error => {
+                this.logDebug(`LMS WebSocket error: ${error.message}`);
+                if (!settled) {
+                    settled = true;
+                    this.connectPromise = null;
+                    reject(error);
+                }
+            });
+            socket.once('close', () => {
+                this.logDebug('LMS WebSocket disconnected');
+                if (this.socket === socket) {
+                    this.socket = null;
+                }
+                if (!settled) {
+                    settled = true;
+                    this.connectPromise = null;
+                    reject(new Error('LMS WebSocket closed before connecting'));
+                }
+                this.#rejectPending(new Error('LMS WebSocket connection closed'));
+                this.#scheduleReconnect();
+            });
+        });
+        return this.connectPromise;
+    }
+
+    #handleMessage(data) {
+        let message;
+        try {
+            message = JSON.parse(data.toString());
+        } catch (error) {
+            this.logDebug(`Invalid LMS WebSocket message: ${error.message}`);
+            return;
+        }
+
+        if (Array.isArray(message.event)) {
+            const [playerId = '', command = [], eventData = {}] = message.event;
+            this.onEvent({
+                playerId: String(playerId),
+                command: Array.isArray(command) ? command.map(String).join(' ') : String(command),
+                data: eventData && typeof eventData === 'object' ? eventData : {},
+            });
+            return;
+        }
+
+        const pending = this.pendingRequests.get(message.id);
+        if (!pending) {
+            return;
+        }
+        this.clearTimeout(pending.timeout);
+        this.pendingRequests.delete(message.id);
+        if (message.error) {
+            const errorMessage = message.error.message || message.error.data || String(message.error);
+            pending.reject(new Error(`LMS WebSocket error: ${errorMessage}`));
+            return;
+        }
+        if (!Object.prototype.hasOwnProperty.call(message, 'result')) {
+            pending.reject(new Error('LMS WebSocket response has no result'));
+            return;
+        }
+        pending.resolve({ ...message, params: message.params || pending.params, ok: true });
+    }
+
+    #rejectPending(error) {
+        for (const pending of this.pendingRequests.values()) {
+            this.clearTimeout(pending.timeout);
+            pending.reject(error);
+        }
+        this.pendingRequests.clear();
+    }
+
+    #scheduleReconnect() {
+        if (this.closed || this.reconnectTimer) {
+            return;
+        }
+        this.reconnectTimer = this.setTimeout(() => {
+            this.reconnectTimer = null;
+            this.start();
+        }, this.reconnectMs);
+    }
+
+    #reportConnectionError(error) {
+        const now = Date.now();
+        if (now - this.lastErrorLog >= ERROR_LOG_INTERVAL_MS) {
+            this.lastErrorLog = now;
+            this.logError(`LMS WebSocket connection to ${this.url.href} failed: ${error.message}`);
+        }
+    }
+
+    #toLegacyError(error) {
+        return {
+            ok: false,
+            message: error instanceof Error ? error.message : String(error || 'Unknown LMS WebSocket error'),
+            error,
+        };
+    }
+}
+
+module.exports = { createWebSocketUrl, LmsWebSocketClient };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iobroker.squeezeboxrpc",
-  "version": "2.0.2",
+  "version": "3.0.0",
   "description": "ioBroker Logitech Squeezebox Adapter over JSON/RPC-Protocol",
   "author": {
     "name": "oweitman",
@@ -25,9 +25,7 @@
   },
   "dependencies": {
     "@iobroker/adapter-core": "^3.4.3",
-    "jayson": "^4.3.0",
-    "lodash": "^4.18.1",
-    "super": "^0.2.3"
+    "ws": "^8.21.3"
   },
   "devDependencies": {
     "@alcalzone/release-script": "^5.2.1",
@@ -84,12 +82,11 @@
     "dev:watchvis2widgets": "npm run start --prefix src-widgets",
     "dev:watchvis1widgets": "npm run watch --prefix widgets",
     "prepublishOnly": "npm run build",
-    "repochecker": "npx github:oweitman/ioBroker.repochecker https://github.com/oweitman/ioBroker.squeezeboxrpc --local --noinfo",
+    "repochecker": "npx @iobroker/repochecker https://github.com/oweitman/ioBroker.squeezeboxrpc --local --env=../iobroker.env",
     "translate": "translate-adapter",
     "translate-widgets": "node ./bin/translate.js --source widgets/squeezeboxrpc/myi18n/en.json --format single",
     "translate-lib": "node ./bin/translate.js --source lib/i18n/ --format multi",
-    "release": "release-script --all",
-    "release:2x": "release-script --all --branch-pattern release2x"
+    "release": "release-script --all"
   },
   "bugs": {
     "url": "https://github.com/oweitman/ioBroker.squeezeboxrpc/issues"

package/widgets/squeezeboxrpc/build/squeezeboxrpc-dist.js

@@ -1361,7 +1361,7 @@
   }
 
   // ../package.json
-  var version = "2.0.2";
+  var version = "3.0.0";
 
   // squeezeboxrpc/js/textImage.js
   String.prototype.regexIndexOf = function(regex, startpos) {